union BitConvert{
float f;
unsigned long ul;
};
unsigned char a,b,c,d;
a = buffer[0];
b = buffer[1];
c = buffer[2];
d = buffer[3];
BitConvert EX;
EX.ul = (a << 24) | (b << 16) | (c << 8) | d;
// or EX.ul = (d << 24) | ( c << 16) | (b << 8) | a; (It is depend on your plaform.)
#includevoid Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0f, 0.0f, 1.0f); glBegin(GL_QUADS); glVertex3f(-0.5f, 0.5f, 0.5f); glVertex3f(0.5f, 0.5f, 0.5f); glVertex3f(0.5f, -0.5f, 0.5f); glVertex3f(-0.5f, -0.5f, 0.1f); glEnd(); glFlush(); } void main() { glutCreateWindow("NeMo"); glutDisplayFunc(Draw); glutMainLoop(); }
#includevoid Capture() { int nx =0, ny = 0; CImage capImage; CWnd *pDesktopWnd = GetDesktopWindow(); HDC hDC = NULL; if(!pDesktopWnd) return; CWindowDC DeskTopDC(pDesktopWnd); nx = GetSystemMetrics(SM_CXSCREEN); ny = GetSystemMetrics(SM_CYSCREEN); if(!capImage.Create(nx, ny, 32)) return; hDC = capImage.GetDC(); BitBlt(hDC, 0,0, nx, ny, DeskTopDC.m_hDC, 0, 0, SRCCOPY); capImage.Save(_T("test.jpg"), Gdiplus::ImageFormatJPEG); capImage.ReleaseDC(); }
int T = time(NULL);
TCHAR str[100];
wsprintf(str,_T("%d.jpg"),T);
ImageTemp.Save(str, Gdiplus::ImageFormatJPEG);
ImageTemp.ReleaseDC();
//////////////////////////////////////////////////////////////////////////
// Made by J.H.KIM, 2011 / feelmare@daum.net, feelmare@gmail.com //
// blog : http://feelmare.blogspot.com //
// My Lab : VISLAB(http://me.pusan.ac.kr) //
//////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <process.h>
#include <windows.h>
struct InputData
{
int * data;
int width;
int height;
int OriginW;
int reserved;
int flag;
};
void ThreadProcessing(void* pParam);
void main()
{
//Data Allocation and Setting
int W = 100;
int H = 100;
int * buffer;
buffer =new int[W*H];
for(int i=0; i<W*H; ++i)
{
buffer[i] = i;
}
int sx,sy,w,h;
//thread1, preparing Transite values
InputData th1_input;
sx = 0; sy = 0; w = 80; h = 90; //(80x90) image processing
th1_input.width = w;
th1_input.height = h;
th1_input.OriginW = W;
th1_input.data = &buffer[sy*W+sx];
th1_input.reserved = 1;
th1_input.flag = TRUE;
_beginthread(ThreadProcessing,0,&th1_input);
//thread2, preparing Transite values
InputData th2_input;
sx = 10; sy = 10; w = 50; h = 50; //(50x50) image processing
th2_input.width = w;
th2_input.height = h;
th2_input.OriginW = W;
th2_input.data = &buffer[sy*W+sx];
th2_input.reserved = 2;
th2_input.flag = TRUE;
_beginthread(ThreadProcessing,0,&th2_input);
//thread3, preparing Transite values
InputData th3_input;
sx = 10; sy = 10; w = 20; h = 20; //(10x10) image processing
th3_input.width = w;
th3_input.height = h;
th3_input.OriginW = W;
th3_input.data = &buffer[sy*W+sx];
th3_input.reserved = 3;
th3_input.flag = TRUE;
_beginthread(ThreadProcessing,0,&th3_input);
//wait until all thread is finished.
while( th1_input.flag || th2_input.flag || th3_input.flag)
{
Sleep(100);
}
//Data buffer release
delete[] buffer;
}
void ThreadProcessing(void* pParam){
//copy struct data to variable
int w = ((InputData*)pParam)->width;
int h = ((InputData*)pParam)->height;
int ow = ((InputData*)pParam)->OriginW;
//Processing Sum(v^2.)
int v;
double sum=0;
for(int j=0; j<h; ++j)
{
for(int i=0; i<w; ++i)
{
v = ((InputData*)pParam)->data[j*ow+i];
sum += (v*v);
}
}
printf("%d thread value = %lf\n", ((InputData*)pParam)->reserved , sum);
((InputData*)pParam)->flag = FALSE;
}
//image class
IplImage* image = 0;
//camera point
CvCapture* capture = cvCaptureFromCAM(0);
//make window
cvNamedWindow( "camera");
//image class for processing
IplImage* image2=0;
//make window
cvNamedWindow( "camera2");
unsigned char R,G,B;
while(1) {
//capture a frame form cam
cvGrabFrame( capture );
//copy to image class
image = cvRetrieveFrame( capture );
//create image at one time in the roof
if(image2 == 0)
{
image2 = cvCreateImage(cvSize(image->width, image->height), image->depth, image->nChannels);
}
//simple image processing
for(int i=0; i<image->height; ++i)
{
for(int j=0; j<image->width; ++j)
{
//to get R,G,B value
B = (unsigned char)image->imageData[i*image->widthStep+j*3+0];
G = (unsigned char)image->imageData[i*image->widthStep+j*3+1];
R = (unsigned char)image->imageData[i*image->widthStep+j*3+2];
//image color converting
B = 255-B;
G = 255-G;
R = 255-R;
//copy R,G,B value to image2
image2->imageData[i*image2->widthStep+j*3+0] = B;
image2->imageData[i*image2->widthStep+j*3+1] = G;
image2->imageData[i*image2->widthStep+j*3+2] = R;
}
}
//show window
cvShowImage( "camera", image );
cvShowImage( "camera2", image2 );
//break
if( cvWaitKey(10) >= 0 )
break;
}
//release imge
cvReleaseImage(&image2);
//release capture point
cvReleaseCapture( &capture );
//close the window
cvDestroyWindow( "camera" );
cvDestroyWindow( "camera2" );
%//////////////////////////////////////////////////////////////////////////
%// Made by J.H.KIM, 2011 / feelmare@daum.net, feelmare@gmail.com //
%// blog : http://feelmare.blogspot.com //
%// Eight-Point Algorithm
%//////////////////////////////////////////////////////////////////////////
clc; clear all; close all;
% Corresponding points between two images
% sample #1 I11.jpg, I22.jpg
%{
load I11.txt; load I22.txt;
m1 = I11; m2 = I22;
%}
%sample #2 I1.jpg, I2.jpg
load I1.txt; load I2.txt;
m1 = I1; m2 = I2;
s = length(m1);
m1=[m1(:,1) m1(:,2) ones(s,1)];
m2=[m2(:,1) m2(:,2) ones(s,1)];
Width = 800; %image width
Height = 600; %image height
% Intrinsic Matrix
load intrinsic_matrix.txt
K = intrinsic_matrix;
% The matrix for normalization(Centroid)
N=[2/Width 0 -1;
0 2/Height -1;
0 0 1];
%%
% Data Centroid
x1=N*m1'; x2=N*m2';
x1=[x1(1,:)' x1(2,:)'];
x2=[x2(1,:)' x2(2,:)'];
% Af=0
A=[x1(:,1).*x2(:,1) x1(:,2).*x2(:,1) x2(:,1) x1(:,1).*x2(:,2) x1(:,2).*x2(:,2) x2(:,2) x1(:,1) x1(:,2), ones(s,1)];
% Get F matrix
[U D V] = svd(A);
F=reshape(V(:,9), 3, 3)';
% make rank 2
[U D V] = svd(F);
F=U*diag([D(1,1) D(2,2) 0])*V';
% Denormalize
F = N'*F*N;
%Verification
%L1=F*m1'; m2(1,:)*L1(:,1); m2(2,:)*L1(:,2); m2(3,:)*L1(:,3);
%%
%Get E
E=K'*F*K;
% Multiple View Geometry 259page
%Get 4 Possible P matrix
P4 = get4possibleP(E);
%Get Correct P matrix
inX = [m1(1,:)' m2(1,:)'];
P1 = [eye(3) zeros(3,1)];
P2 = getCorrectCameraMatrix(P4, K, K, inX)
%%
%Get 3D Data using Direct Linear Transform(Linear Triangular method)
Xw = Triangulation(m1',K*P1, m2',K*P2);
xx=Xw(1,:);
yy=Xw(2,:);
zz=Xw(3,:);
figure(1);
plot3(xx, yy, zz, 'r+');
%{
%This code is also run well instead of Triangulation Function.
nm1=inv(K)*m1';
nm2=inv(K)*m2';
% Direct Linear Transform
for i=1:s
A=[P1(3,:).*nm1(1,i) - P1(1,:);
P1(3,:).*nm1(2,i) - P1(2,:);
P2(3,:).*nm2(1,i) - P2(1,:);
P2(3,:).*nm2(2,i) - P2(2,:)];
A(1,:) = A(1,:)./norm(A(1,:));
A(2,:) = A(2,:)./norm(A(2,:));
A(3,:) = A(3,:)./norm(A(3,:));
A(4,:) = A(4,:)./norm(A(4,:));
[U D V] = svd(A);
X(:,i) = V(:,4)./V(4,4);
end
%}
#include <iostream>
#include <cmath>
#include <time.h>
#include <vector>
#include <algorithm>
using namespace std;
class element{
public:
element(float a, int b){
value = a;
index = b;
}
float value;
int index;
};
bool compare(const element &a, const element &b )
{
return a.value < b.value; //μ€λ¦μ°¨μ(ascending order)
//return a.value > b.value; //λ΄λ¦Όμ°¨μ(descending order)
}
void main()
{
srand( (unsigned int)time(NULL));
vector< element > A;
// κ° λ£κΈ° (input value)/////////////////////////////////////////////
for(int i=0; i<20000; ++i){
A.push_back( element(rand()%10, i) );
}
//κ° μΆλ ₯ (data print)///////////////////////////////////////////////
printf("μ λ ¬ μ (Before ordering) \n");
for(i=0; i<20000; ++i){
printf("A[%d] -> value %f :: index -> %d\n", i, A[i].value, A[i].index );
}
//μ λ ¬ (sorting)
sort(A.begin(),A.end(),compare);
//κ° μΆλ ₯ (Value print)
printf("μ λ ¬ ν(After ordering)\n");
for(i=0; i<20000; ++i){
printf("A[%d] -> value %f :: index -> %d\n", i, A[i].value, A[i].index );
}
}
