2³=8

2⁴=16

2ⁿ10일때 n=?

이걸

n=log₂10

c언어로는 

n = log(10)/log(2);

자연상수e라는것도 있는데 이게 밑을 이야기하고

log(eⁿ)일경우 n을 반환

몇제곱인지 빠르게 구할수 있다

부동소수점이므로 주의

처음에 

solid 이름

을 써넣고

facet normal 0.000000 0.000000 1.000000

outer loop

vertex -1.000000 2.000000 0.000000

vertex 1.000000 2.000000 0.000000

vertex 1.000000 4.000000 0.000000

endloop

endfacet

를 넣고

마지막으로

endsolid Exported 이름

을 넣는다

벡터방향으로 봤을때 반시계로 해야함

안 그러면 노말이 달라질수도 있으니 주의

x가 앞

y가 오른쪽

z가 위

카메라 매핑은 임의의 직선을 그어서 사각형이 존재하는지 추적하고

퍼센트 연산으로 일정비율로 감소하는지 검사

퍼센트 연산으로 오차검사

특징점 연산으로 포인트 추정

사각형을 그리는 예제

solid Exported from 이름 (sub 0)

facet normal 0.000000 0.000000 1.000000

outer loop

vertex -1.000000 -1.000000 0.000000

vertex 1.000000 -1.000000 0.000000

vertex 1.000000 1.000000 0.000000

endloop

endfacet

facet normal 0.000000 0.000000 1.000000

outer loop

vertex 1.000000 1.000000 0.000000

vertex -1.000000 1.000000 0.000000

vertex -1.000000 -1.000000 0.000000

endloop

endfacet

endsolid 이름 

is_block_type_valid(header- _block_use)

/*

CascadeClassifier를 전역으로 끄집어내니까 발생했음

그런데 실제론 vector메모리 문제라서 직접 할당해야함

vector<Rect> face_pos; 

face_pos.reserve(50);

이런식으로 쓰면됨

*/

wntdll_pdb로드되지 않음

/*

sleep함수를 쓰거나 종료될때 발생함

*/

#include "opencv2\opencv.hpp"  //기본적으로 불러오는 헤더

static CascadeClassifier face_Cascade //검색 시스템의 클래스

face.load("haarcascade_frontalface_default.xml")) //이런식으로 불러와서 사용, 성공시 true반환

face_Cascade.detectMultiScale(Mat 이미지,vector<Rect> 저장할 위치, 지정된 값만큼 스케일을 바꾸면서 검색, 후보를 몇개나 찾아볼지, 검색옵션(하단참조)CV_HAAR_FIND_BIGGEST_OBJECT 

,Size 최소 사이즈 Size(10,10)이렇게 쓰면 됨,Size 최대사이즈)

검색옵션(or연산으로 중첩가능)

CV_HAAR_FIND_BIGGEST_OBJECT 중첩시 가장 큰거만 반환

CV_HAAR_SCALE_IMAGE 이미지의 스케일을 바꾸면서 검색

CV_HAAR_DO_ROUGH_SEARCH 한개만 찾음

Mat는 2차원 배열같은것, img대용품

cvtColor(입력 Mat, 출력 Mat, CV_RGB2GRAY); //그레이생성

cvSetImageROI(img_buff,cvRect(0,0, img_buff.size().width, img_buff.size().height)); //스케일변경인줄 알았는데 아닌듯

circle(Mat형 이미지, Point(x,y),크기,색상 Scalar(0, 0, 255),굵기,0);//원그리기

putText(Mat 이미지,표시할 문자열,Point(x,y),폰트 (하단참조),폰트 굵기(기본값1),색상 Scalar(255, 255, 255))

CV_FONT_HERSHEY_SIMPLEX //산세리프폰트 중간크기

CV_FONT_HERSHEY_PLAIN //산세리프폰트 작은크기

CV_FONT_HERSHEY_DUPLEX //세리프폰트 2줄

CV_FONT_HERSHEY_COMPLEX //세리프폰트 중간크기

CV_FONT_HERSHEY_TRIPLEX //세리프폰트 3줄

CV_FONT_HERSHEY_COMPLEX_SMALL //세리프폰트 작은크기

CV_FONT_HERSHEY_SCRIPT_SIMPLEX //필기체

CV_FONT_ITALC //이탤릭체

Mat img = imread("Lenna.png"); //이미지열기

imwrite("copy.jpg", img );//저장하기

mat접근방법

//at접근, 간편하지만 느림

if (img_t.type() == CV_8UC1)//단일8비트 채널

{

for (int i = 0; i < img_t.cols; i ++)//x축

{

for (int j = 0; j < img_t.rows; j ++)//y축

{

img_t.at<uchar>(i, j) = 255;//밝기

}

}

}

if (img_t.type() == CV_8UC3)//3색 8비트 채널 

{

for (int i = 0; i < img_t.cols; i ++)//x축

{

for (int j = 0; j < img_t.rows; j ++)//y축

{

img_t2.at<Vec3b>(j, i)[0] = 255;//B

img_t2.at<Vec3b>(j, i)[1] = 255;//G

img_t2.at<Vec3b>(j, i)[2] = 255;//R

img_t2.at<Vec3b>(j, i)= Vec3b(255,255,255);//BGR

}

}

}

포인터접근

if (img_t2.type()==CV_8UC3)//3색 8비트 채널 

{

float _t;

int img_t2_channels= img_t2.channels();

for (int j = 0; j < img_t2.rows; j++)//y축

{

uchar * ptr_img_t = img_t2.ptr<uchar>(j);

for (int i = 0; i < img_t2.cols*img_t2_channels; i += img_t2_channels)//x축

{

float r, g, b, _max, _min;

float h, s, v;

//if (img_t2.channels() == 3)

r = ptr_img_t[i + 2];

g = ptr_img_t[i + 1];

b = ptr_img_t[i + 0];

}

}

}

캠 연결

속성을 연다

c++일반의 디렉터리를 다음으로 바꿔준다

D:/OpenCV_2.4.12/opencv/build/include;%(AdditionalIncludeDirectories)

필요에 따라 해당위치로 가서 include할 파일을 폴더에서 꺼내준다

D:/OpenCV_2.4.12/opencv/build/include

를 추가하고 엔터

D:\OpenCV_2.4.12\opencv\build\x86\vc12\lib

를 추가하고 엔터

링커일반의 추가 라이브러리 디렉터리를 다음으로 바꿔준다

D:\OpenCV_2.4.12\opencv\build\x86\vc12\lib;%(AdditionalLibraryDirectories)

링커 입력란의 원래 있었던 종속성에 아래의 종속성을 추가해준다

원래 있었던 종속성

kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)

추가할 종속성

opencv_kit_2_4_12프로젝트용.zip를 프로젝트에 푼다

(알짜 모아서 직접 압축한거)

https://drive.google.com/open?id=1lsoj2iAXnFZXSW5hz5DCoAavLhg_B-XH

헤더에 

#include <opencv2\opencv.hpp>

를 넣고 쓴다

좌표계산

https://wmmu.tistory.com/entry/%EC%9C%A0%EB%8B%88%ED%8B%B0-%EC%A2%8C%ED%91%9C%EA%B3%84%EC%82%B0-%EB%AA%A8%EC%9D%8C

결과값이 좌표일 경우에는 위 링크로

결과값이 각도일 경우에는 이 글을 이용

pos1에서 pos2에대한 각도

Vector3 relativePos = pos2-pos1; 
Quaternion rotation = Quaternion.LookRotation (relativePos, Vector3.up );

상대 회전각

dir_speed=target.transform.rotation*Quaternion.Inverse(dir_previous);

상대 회전각2

a에서 b에대한 각도(위와 같음)

var a = Quaternion.Euler(0, 15, 0);
var b = Quaternion.Euler(0, 20, 0);
Debug.DrawLine(Vector3.zero, a * Vector3.forward, Color.red);
Debug.DrawLine(Vector3.zero, b * Vector3.forward, Color.blue);
Debug.DrawLine(Vector3.zero, (Quaternion.Inverse(a) * b) * Vector3.forward, Color.green);

상대회전각3

테스트는 안 해봄

var rotRel=Quaternion.FromToRotation(fromDir,ToDir);

각도 반전

var rotInverse=Quaternion.Inverse(transform.rotation);

speed = Quaternion.euler (0,0,0) * new vector3(0,0,0);  //len_vec과 동일

pDir(pointDirection)

2D계산용
수학계산을 이용한다. 일반적으로는 아래의 SignedAngle사용

    float PointDirection(Vector2 vec2)
    {
        vec2 = vec2.normalized;
        float offset;
        if (vec2.x > 0)
        {
            if (vec2.y > 0)
            {
                offset = 0;
            }
            else
            {
                var t = vec2.x;
                vec2.x = -vec2.y;
                vec2.y = t;

                offset = 270;
            }
        }
        else
        {
            if (vec2.y > 0)
            {
                var t = vec2.x;
                vec2.x = vec2.y;
                vec2.y = -t;

                offset = 90;
            }
            else
            {
                vec2.x = -vec2.x;
                vec2.y = -vec2.y;

                offset = 180;
            }
        }
        if (vec2.x == 0)
        {
            return 0;
        }
        return (Mathf.Atan(vec2.y / vec2.x) * Mathf.Rad2Deg) + offset;
    }

PDir

3D계산

var direction = Quaternion.LookRotation(pos2- pos1, Vector3.up);

PDir2D

좌현이 기준각도라서

Vector2.right를 좌현에 두고 쓰면 겜메랑 똑같이 나온다

Debug.Log(Vector2.SignedAngle(Vector2.zero, Vector2.up)); //0
Debug.Log(Vector2.SignedAngle(Vector2.zero, Vector2.down)); //0
Debug.Log(Vector2.SignedAngle(Vector2.zero, Vector2.left)); //0
Debug.Log(Vector2.SignedAngle(Vector2.zero, Vector2.right)); //0

Debug.Log(Vector2.SignedAngle(Vector2.right, Vector2.up)); //90
Debug.Log(Vector2.SignedAngle(Vector2.right, Vector2.down)); //-90
Debug.Log(Vector2.SignedAngle(Vector2.right, Vector2.left)); //180
Debug.Log(Vector2.SignedAngle(Vector2.right, Vector2.right)); //0

Debug.Log(Vector2.SignedAngle(Vector2.up, Vector2.up)); //0
Debug.Log(Vector2.SignedAngle(Vector2.up, Vector2.down)); //180
Debug.Log(Vector2.SignedAngle(Vector2.up, Vector2.left)); //90
Debug.Log(Vector2.SignedAngle(Vector2.up, Vector2.right)); //-90

Vector2.Angle 예제

Debug.Log(Vector2.Angle(Vector2.zero, Vector2.up)); //0
Debug.Log(Vector2.Angle(Vector2.zero, Vector2.down)); //0
Debug.Log(Vector2.Angle(Vector2.zero, Vector2.left)); //0
Debug.Log(Vector2.Angle(Vector2.zero, Vector2.right)); //0

Debug.Log(Vector2.Angle(Vector2.right, Vector2.up)); //90
Debug.Log(Vector2.Angle(Vector2.right, Vector2.down)); //90
Debug.Log(Vector2.Angle(Vector2.right, Vector2.left)); //180
Debug.Log(Vector2.Angle(Vector2.right, Vector2.right)); //0

Debug.Log(Vector2.Angle(Vector2.up, Vector2.up)); //0
Debug.Log(Vector2.Angle(Vector2.up, Vector2.down)); //180
Debug.Log(Vector2.Angle(Vector2.up, Vector2.left)); //90
Debug.Log(Vector2.Angle(Vector2.up, Vector2.right)); //90

DeltaAngle예제

-179.9~180각도 Normalize용 (정규화)

일반적으론 좌현을 0으로 두고 쓰면 된다

Debug.Log(Mathf.DeltaAngle(0, -270)); //90
Debug.Log(Mathf.DeltaAngle(0, -180)); //180
Debug.Log(Mathf.DeltaAngle(0, -90)); //-90
Debug.Log(Mathf.DeltaAngle(0, 0)); //0
Debug.Log(Mathf.DeltaAngle(0, 90)); //90
Debug.Log(Mathf.DeltaAngle(0, 180)); //180
Debug.Log(Mathf.DeltaAngle(0, 270)); //-90

Debug.Log(Mathf.DeltaAngle(90, -270)); //0
Debug.Log(Mathf.DeltaAngle(90, -180)); //90
Debug.Log(Mathf.DeltaAngle(90, -90)); //180
Debug.Log(Mathf.DeltaAngle(90, 0)); //-90
Debug.Log(Mathf.DeltaAngle(90, 90)); //0
Debug.Log(Mathf.DeltaAngle(90, 180)); //90
Debug.Log(Mathf.DeltaAngle(90, 270)); //180

각도정규화 

v1

public double d_set(double _Dir)
{
    if(_Dir<0d)
    {
        _Dir=360d-((-_Dir)%360d);
    }
    if(_Dir>=360d)
    {
        return _Dir%360d;
    }
    return _Dir;
}

v2

dir = (dir % 360f + 360f) % 360f;

v3

dir = Mathf.Repeat(dir, 360f);

각도정규화 (쉐이더용)

0~1로 정규화 한다

dir = frac(dir);

Dot예제

각도 연산을 바로 인풋으로 받아들일때 쓰면 편하다

Debug.Log(Vector2.Dot(Vector2.zero, Vector2.up)); //0
Debug.Log(Vector2.Dot(Vector2.zero, Vector2.down)); //0
Debug.Log(Vector2.Dot(Vector2.zero, Vector2.left)); //0
Debug.Log(Vector2.Dot(Vector2.zero, Vector2.right)); //0

Debug.Log(Vector2.Dot(Vector2.right, Vector2.up)); //0
Debug.Log(Vector2.Dot(Vector2.right, Vector2.down)); //0
Debug.Log(Vector2.Dot(Vector2.right, Vector2.left)); //-1
Debug.Log(Vector2.Dot(Vector2.right, Vector2.right)); //1

Debug.Log(Vector2.Dot(Vector2.up, Vector2.up)); //1
Debug.Log(Vector2.Dot(Vector2.up, Vector2.down)); //-1
Debug.Log(Vector2.Dot(Vector2.up, Vector2.left)); //0
Debug.Log(Vector2.Dot(Vector2.up, Vector2.right)); //0

두 벡터간 각도차이

Vector3.Angle(ray.direction, Camera.main.transform.forward)

특정 시야각 안에 들어왔는지 검사

bool IsInFOV(Vector3 position, float fovRatio)
{
    var cam = Camera.main;
    if (cam == null)
    {
        return false;
    }
    var direction = position - cam.transform.position;
    var angle = Vector3.Angle(cam.transform.forward, direction);
    var fov = cam.fieldOfView * fovRatio;
    if (angle > fov)
    {
        return false;
    }
    return true;
}

특정 시야각 안에 들어왔는지 검사2

targetingCircle.GetComponent<Image>().color = Color.white;
targetingCircle.GetComponent<FovToRectsize>().fov = GetWeapon().GetComponent<Gun>().spread * 2;
var fov = targetingCircle.GetComponent<FovToRectsize>().fov;
var targets = GameSystem.GetInGameOtherCharacters();
var cam = Camera.main;
var targeting = false;
foreach (var target in targets)
{
    Debug.DrawLine(transform.position, target.transform.position, Color.cyan);
    var directionToTarget = target.transform.position - cam.transform.position;
    var angle = Vector3.Angle(cam.transform.forward, directionToTarget);
    if (angle > fov)
    {
        continue;
    }

    var humanoidAnimatorController = target.GetComponentInChildren<HumanoidAnimatorController>();


    //디버깅이 원활하도록 배열로 한번에 안 만들고 하나씩 추가함
    var targetPoses = new List<Vector3>();
    targetPoses.Add(target.transform.position);
    targetPoses.Add(humanoidAnimatorController.GetBoneTransform(HumanBodyBones.Hips).position);
    targetPoses.Add(humanoidAnimatorController.GetBoneTransform(HumanBodyBones.Head).position);

    foreach (var targetPos in targetPoses)
    {
        if (Physics.Raycast(cam.transform.position, targetPos - cam.transform.position, out RaycastHit hit, maxDistance: 100))
        {
            Debug.DrawRay(cam.transform.position, targetPos - cam.transform.position, Color.red);
            if (hit.transform.tag == "Player")
            {
                Debug.DrawLine(targetPos, targetPos + Vector3.up, Color.red);
                targeting = true;
                break;
            }
        }
    }
    if (targeting)
    {
        break;
    }
}
{
    //정중앙에 보고 있는게 닿았는지 검사
    if (Physics.Raycast(cam.transform.position, cam.transform.forward, out RaycastHit hit))
    {
        Debug.DrawRay(cam.transform.position, cam.transform.forward, Color.red);
        if (hit.transform.tag == "Player")
        {
            targeting = true;
        }
    }
}
if (targeting)
{
    targetingCircle.GetComponent<Image>().color = new Color(1, 0.5f, 0.5f);
}

맞은 각도 표시

firePosition은 발사지점

var relativePosition = Quaternion.Inverse(transform.rotation) * (firePosition - transform.position);
var relativePosition2D = new Vector2(relativePosition.x, -relativePosition.z);

var rot = Quaternion.Euler(0, 0, Vector2.SignedAngle(relativePosition2D, Vector2.right));
damageUI.transform.rotation = rot;

겜메 시절에 3D구현한다고 만들어 쓰던거

유니티에선 쓸일이 없지만 윈폼, 아두이노등 3D 연산 미지원 언어들에선 쓸만함

double Rad2Deg=180.0/3.14;

double Deg2Rad=3.14/180.0;  



Vector3 len_vec(float len, float dir_x, float dir_y, float dir_z)

{



    Vector3 _return;

    double _len_z_x;

    _len_z_x= len_x(len, (double)dir_y);



    _return.x = (float)len_x(_len_z_x, (double)dir_z);

    _return.y = (float)len_y(_len_z_x, (double)dir_z);

    _return.z = (float)len_y(len, (double)dir_y);

    return _return;

}

Vector3 len_vec(float len, Vector3 dir)

{



    Vector3 _return;

    double _len_z_x;

    _len_z_x= len_x(len, (double)dir.y);



    _return.x = (float)len_x(_len_z_x, (double)dir.z);

    _return.y = (float)len_y(_len_z_x, (double)dir.z);

    _return.z = (float)len_y(len, (double)dir.y);

    return _return;

}



Vector3 len_vec(double len, Vector3 dir)

{

    //unity

    Vector3 _return;

    double _len_z_x;

    

    _len_z_x= len_x(len, -dir.x);

    _return.y = len_y(len, -dir.x);

    _return.z = len_x(_len_z_x, dir.y);

    _return.x = len_y(_len_z_x, dir.y);

    return _return;

}

float len_vec(Vector3 vec, Vector3 dir)

{

Vector3 _return_vec=vec;

float dir_t;



dir_t=_return_vec.y;

_return_vec.y=len_x(dir_t,_return_vec.z,dir.x);

_return_vec.z=len_y(dir_t,_return_vec.z,dir.x);



dir_t=_return_vec.x;

_return_vec.x=len_x(dir_t,_return_vec.z,dir.y);

_return_vec.z=len_y(dir_t,_return_vec.z,dir.y);



dir_t=_return_vec.x;

_return_vec.x=len_x(dir_t,_return_vec.y,dir.z);

_return_vec.y=len_y(dir_t,_return_vec.y,dir.z);



return _return_vec;

}



    

float len_x(float x, float y, float dir)

{

float _return_x;

_return_x=len_x(x,dir);

_return_x+=len_y(y,-dir);

return _return_x;

}

float len_y(float x, float y, float dir)

{

float _return_y;

_return_y=len_y(x,dir);

_return_y+=len_x(y,-dir);

return _return_y;

}

Vector2 len_vec(Vector2 vec, float dir)

{

Vector2 _return_vec;

_return_vec.x=len_x(vec.x,dir);

_return_vec.y=len_y(vec.x,dir);

_return_vec.x+=len_y(vec.y,-dir);

_return_vec.y+=len_x(vec.y,-dir);

return _return_vec;

}



//x와 각도를 이용해 y를 구함

float x_and_angle_get_y(float x , float dir)

{

//return y

return tan(dir*0.01745329222)*x;

}

    float len_x(float len, float dir)//유니티

    {

        return Mathf.Cos((float)(dir * Mathf.PI / 180.0)) * len;

    }

    float len_y(float len, float dir)//유니티

    {

        return Mathf.Atan((float)(dir * Mathf.PI / 180.0)) * len;

    }

float len_x(float len, float dir)

{

return cos(dir*0.01745329222)*len;

}


float len_y(float len, float dir)

{

return sin(dir*0.01745329222)*len;

}


    float dir_normalized(float dir)

    {

        if (dir < 0)

        {

            return 360-(-dir % 360);

        }

        return dir % 360;

    }

    float get_dir(Vector2 FromVec, Vector2 ToVec)

    {

        return get_dir(ToVec-FromVec);

    }



    float get_dir( Vector2 ToVec)

    {

        ToVec = ToVec.normalized;

        return Mathf.Atan2(ToVec.x, ToVec.y) * Mathf.Rad2Deg;

    }


    float get_dir( Vector2 ToVec)

    {

        ToVec = ToVec.normalized;

        return Mathf.Atan(ToVec.y/ToVec.x) * Mathf.Rad2Deg;

    }

        public double d_set(double _Dir)
        {
            if (_Dir < 0d)
            {
                _Dir = 360d - ((-_Dir) % 360d);
            }
            if (_Dir >= 360d)
            {
                return _Dir % 360d;
            }
            return _Dir;
        }
        public double d_set(double _Dir)
        {
           while(_Dir < 0)
            {
                _Dir += 360;
            }
           while(_Dir >= 360)
            {
                _Dir -= 360;
            }
            return _Dir;
        }



public double d_set_a(double _Dir)

{

    _Dir=d_set(_Dir);

    if(_Dir>180)

    {

      return _Dir-360;

    }

    return _Dir;

}

Vector3 d_set(Vector3 _Dir)

{

  //unity

    _Dir.x=d_set_a(_Dir.x);

    _Dir.y=d_set(_Dir.y);

    _Dir.z=d_set(_Dir.z);

    if(abs(_Dir.x)>90)

    {

      _Dir.x=d_set_a(180-_Dir.x);

      _Dir.y=d_set(_Dir.y+180);

      _Dir.z=d_set(_Dir.z+180);

    }

    return _Dir;

}