void ui::OnFreshenDNSInfo()
{
m_p_last_selected_dns_item = nullptr;
m_orgin_dns_item_color = 0xFFFFFFFF;
m_p_dns_info_list->RemoveAll();
m_map_dns_item_ip.clear();
EnableUserOperation(false);
std::thread(
[this]()
{
std::shared_ptr<freshen_dns_info_result_data> sp_res_data = std::make_shared<freshen_dns_info_result_data>();
result res = m_p_notifyer->on_freshen_dns_info(*sp_res_data.get());
if (res != result_success)
{
showerror("Ë¢ÐÂDNSʧ°Ü-->[%s]", result_string(res));
EnableUserOperation(true);
return;
}
post_call(
[this, sp_res_data]()
{
showlog("Ë¢ÐÂDNSÁбíºÄʱ[%ws]", sp_res_data->_str_freshen_take_time.c_str());
for (auto it : sp_res_data->_vec_ip_dns_info)
{
ui_dns_info& info = it;
DuiLib::CDialogBuilder builder;
DuiLib::CListContainerElementUI* p_item = static_cast<DuiLib::CListContainerElementUI*>(builder.Create(_T("dns_info_item.xml"), (UINT)0, NULL, &m_PaintManager));
Assert(p_item != nullptr);
if (m_orgin_dns_item_color == 0xFFFFFFFF)
{
m_orgin_dns_item_color = p_item->GetBkColor();
}
DuiLib::CLabelUI* p_dns_vip_label = static_cast<DuiLib::CLabelUI*>(p_item->FindSubControl(_T("dns_vip_label")));
Assert(p_dns_vip_label != nullptr);
DuiLib::CLabelUI* p_dns_uptime_label = static_cast<DuiLib::CLabelUI*>(p_item->FindSubControl(_T("dns_uptime_label")));
Assert(p_dns_uptime_label != nullptr);
DuiLib::CLabelUI* p_dns_ping_t_ms_label = static_cast<DuiLib::CLabelUI*>(p_item->FindSubControl(_T("dns_ping_t_ms_label")));
Assert(p_dns_ping_t_ms_label != nullptr);
p_dns_vip_label->SetText(info._str_vip.c_str());
p_dns_uptime_label->SetText(info._str_uptime.c_str());
p_dns_ping_t_ms_label->SetText(info._str_ping_t_ms.c_str());
m_p_dns_info_list->Add(p_item);
m_map_dns_item_ip.insert(std::make_pair(p_item, info._str_vip));
}
EnableUserOperation(true);
}
);
}
).detach();
}
int main(int argc, char *argv[])
{
cv::VideoCapture cap(0);
// 設定しても反映されていないかもだから注意
cap.set(CV_CAP_PROP_FRAME_WIDTH, 240);
cap.set(CV_CAP_PROP_FRAME_HEIGHT, 160);
// カメラがオープンできたかの確認
if (!cap.isOpened())
{
return -1;
}
cv::namedWindow("Capture", CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);
cv::namedWindow("Diff", CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);
ResultSet* result = new ResultSet();
FILE * mylog;
char logf[BSIZE];
sprintf_s<BSIZE>(logf, DATA_DIR LOGFILE);
fopen_s(&mylog, logf, "w");
while (1) {
preproc(cap, result);
//映像が安定してから処理開始
if (result->serial > START_FRAME)
{
makeDiff(result);
result->nPix = countMat(result->diff);
boundFace(result);
}
result->serial++;
result->prev = result->gray.clone();
//output log
writelog(mylog, result);
writeilog(result);
showlog(result);
if (result->serial > MAX_FRAME)
{
break;
}
Sleep(waitmil - WAITKEYMIL);
}
if (mylog != NULL)
{
fclose(mylog);
}
if (result != NULL)
{
delete result;
}
return 0;
}
static int
output_one_prop(char ope, unsigned char *edata)
{
int i;
unsigned char pdc;
unsigned char *dp = edata;
showlog("%c,", ope); /* Set -or- Get */
showlog("%02x,", dp[0]); /* EPC */
pdc = dp[1];
showlog("%02x,", pdc); /* PDC */
dp += 2;
for (i = 0; i < pdc; i++) {
showlog("%02x", *dp++);
}
showlog("\n");
return dp - edata;
}
void ui::OnAutoDone()
{
EnableUserOperation(false);
std::thread(
[this]()
{
std::wstring take_time;
result res = m_p_notifyer->on_auto_done(take_time);
if (res == result_success)
{
showlog("×Ô¶¯ÓÅ»¯DNS³É¹¦£¬ºÄʱ[%ws]", take_time.c_str());
}
else
{
showerror("×Ô¶¯ÓÅ»¯DNSʧ°Ü-->[%s]", result_string(res));
}
EnableUserOperation(true);
}
).detach();
}
void compile_shader(GLuint shader, const char *file_name)
{
// Read shader source from file_name
FILE *fh = fopen(file_name, "r");
if(!fh) {
printf("Error: Failed to open shader\n");
}
struct stat statbuf;
stat(file_name, &statbuf);
char *shader_source = (char *) malloc(statbuf.st_size + 1);
fread(shader_source, statbuf.st_size, 1, fh);
shader_source[statbuf.st_size] = '\0';
// Compile shader
const GLchar *gl_shader_source = shader_source;
glShaderSource(shader, 1, &gl_shader_source, NULL);
glCompileShader(shader);
showlog(shader);
free(shader_source);
}
GLuint LoadShader(const char *source, GLenum type)
{
GLuint shader = glCreateShader(type);
check();
glShaderSource(shader, 1, &source, NULL);
check();
glCompileShader(shader);
check();
GLint compiled;
glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
if(compiled != GL_TRUE)
{
showlog(shader);
glDeleteShader(shader);
return 0;
}
return shader;
}
GLuint modelEngine::loadShader(char *shaderFile, GLenum shaderType, int shaderIndex)
{
FILE* shaderDataFile;
GLuint shaderHandle = 0;
// Get file stats
struct stat st;
int numBytesRead = 0;
int numShaders = 0;
// If we have room for shaders
if(numShaders < MAX_SHADER_PROGRAMS - 1)
{
// Create shader
stat(shaderFile, &st);
// First read contents of file
shaderDataFile = fopen(shaderFile, "rb");
if(shaderDataFile)
{
// Read data from file
numBytesRead = fread(shaderDataRAM1, 1, st.st_size, shaderDataFile);
shaderDataLengthRAM1 = numBytesRead;
// Create shader
shaderHandle = glCreateShader(shaderType);
// Set shader source
glShaderSource(shaderHandle, 1, &shaderDataConst1, shaderDataLength1);
// Compile shader
glCompileShader(shaderHandle);
checkGLError();
// Check success
showlog(shaderHandle);
fclose(shaderDataFile);
}
// If successfull
if(shaderHandle != 0)
{
// Store shader
if(shaderType == GL_VERTEX_SHADER)
{
shaders[shaderIndex].vertexShader = shaderHandle;
}
else
{
shaders[shaderIndex].fragmentShader = shaderHandle;
}
// Return shader handle
return shaderHandle;
}
else
{
return -1;
}
}
else
{
return -1;
}
}
int main(int argc, char *argv[])
{
bcm_host_init();
// Start OGLES
init_ogl(state);
//////////////////////
// Setup vertices
/////////////////////
// Vertices
static const GLfloat vertices[] = {
-0.5f, 0.5f,
0.5f, 0.5f,
0.5f, -0.5f,
-0.5f, -0.5f
};
// Generate vertex buffer
GLuint vbo;
glGenBuffers(1, &vbo);
// Set buffer
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// Fill buffer
glBufferData(GL_ARRAY_BUFFER, 2*4*sizeof(GLfloat), vertices, GL_STATIC_DRAW);
// Elements
GLubyte elements[] = {
2, 3, 0,
0, 1, 2
};
// Generate element buffer
GLuint ebo;
glGenBuffers(1, &ebo);
// Set buffer
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
// Fill buffer
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 2*3*sizeof(GLubyte), elements, GL_STATIC_DRAW);
/////////////////////
// Setup shaders
////////////////////
// Compile vertex shader
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexSource, NULL);
glCompileShader(vertexShader);
showlog(vertexShader);
// Compile frag shader
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
glCompileShader(fragmentShader);
showlog(fragmentShader);
// Create shader program
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
// Link and use program
glLinkProgram(shaderProgram);
glUseProgram(shaderProgram);
// Specify and enable vertex attribute
GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(posAttrib);
// Clear the screen
glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Event loop
while(!terminate)
{
// Draw square
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);
// Swap buffers
eglSwapBuffers(state->display, state->surface);
}
// Clean up before exit
exit_func();
return 0;
}
static void init_shaders(CUBE_STATE_T *state)
{
static const GLfloat vertex_data[] = {
-1.0,-1.0,1.0,
1.0,-1.0,1.0,
1.0,1.0,1.0,
-1.0,1.0,1.0,
};
const GLchar *vshader_source =
"attribute vec4 vertex;"
"varying vec2 tcoord;"
"void main(void) {"
" vec4 pos = vertex;"
" gl_Position = pos;"
" tcoord = vertex.xy*0.5+0.5;"
"}";
#if 0
//Mandelbrot
const GLchar *mandelbrot_fshader_source =
"uniform vec4 color;"
"uniform vec2 scale;"
"uniform vec2 centre;"
"varying vec2 tcoord;"
"void main(void) {"
" float intensity;"
" vec4 color2;"
" float cr=(gl_FragCoord.x-centre.x)*scale.x;"
" float ci=(gl_FragCoord.y-centre.y)*scale.y;"
" float ar=cr;"
" float ai=ci;"
" float tr,ti;"
" float col=0.0;"
" float p=0.0;"
" int i=0;"
" for(int i2=1;i2<16;i2++)"
" {"
" tr=ar*ar-ai*ai+cr;"
" ti=2.0*ar*ai+ci;"
" p=tr*tr+ti*ti;"
" ar=tr;"
" ai=ti;"
" if (p>16.0)"
" {"
" i=i2;"
" break;"
" }"
" }"
" color2 = vec4(float(i)*0.0625,0,0,1);"
" gl_FragColor = color2;"
"}";
// Julia
const GLchar *julia_fshader_source =
"uniform vec4 color;"
"uniform vec2 scale;"
"uniform vec2 centre;"
"uniform vec2 offset;"
"varying vec2 tcoord;"
"uniform sampler2D tex;"
"void main(void) {"
" float intensity;"
" vec4 color2;"
" float ar=(gl_FragCoord.x-centre.x)*scale.x;"
" float ai=(gl_FragCoord.y-centre.y)*scale.y;"
" float cr=(offset.x-centre.x)*scale.x;"
" float ci=(offset.y-centre.y)*scale.y;"
" float tr,ti;"
" float col=0.0;"
" float p=0.0;"
" int i=0;"
" vec2 t2;"
" t2.x=tcoord.x+(offset.x-centre.x)*(0.5/centre.y);"
" t2.y=tcoord.y+(offset.y-centre.y)*(0.5/centre.x);"
" for(int i2=1;i2<16;i2++)"
" {"
" tr=ar*ar-ai*ai+cr;"
" ti=2.0*ar*ai+ci;"
" p=tr*tr+ti*ti;"
" ar=tr;"
" ai=ti;"
" if (p>16.0)"
" {"
" i=i2;"
" break;"
" }"
" }"
" color2 = vec4(0,float(i)*0.0625,0,1);"
" color2 = color2+texture2D(tex,t2);"
" gl_FragColor = color2;"
"}";
state->vshader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(state->vshader, 1, &vshader_source, 0);
glCompileShader(state->vshader);
check();
if (state->verbose)
showlog(state->vshader);
state->fshader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(state->fshader, 1, &julia_fshader_source, 0);
glCompileShader(state->fshader);
check();
if (state->verbose)
showlog(state->fshader);
state->mshader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(state->mshader, 1, &mandelbrot_fshader_source, 0);
glCompileShader(state->mshader);
check();
if (state->verbose)
showlog(state->mshader);
// julia
state->program = glCreateProgram();
glAttachShader(state->program, state->vshader);
glAttachShader(state->program, state->fshader);
glLinkProgram(state->program);
check();
if (state->verbose)
showprogramlog(state->program);
state->attr_vertex = glGetAttribLocation(state->program, "vertex");
state->unif_color = glGetUniformLocation(state->program, "color");
state->unif_scale = glGetUniformLocation(state->program, "scale");
state->unif_offset = glGetUniformLocation(state->program, "offset");
state->unif_tex = glGetUniformLocation(state->program, "tex");
state->unif_centre = glGetUniformLocation(state->program, "centre");
// mandelbrot
state->program2 = glCreateProgram();
glAttachShader(state->program2, state->vshader);
glAttachShader(state->program2, state->mshader);
glLinkProgram(state->program2);
check();
if (state->verbose)
showprogramlog(state->program2);
state->attr_vertex2 = glGetAttribLocation(state->program2, "vertex");
state->unif_scale2 = glGetUniformLocation(state->program2, "scale");
state->unif_offset2 = glGetUniformLocation(state->program2, "offset");
state->unif_centre2 = glGetUniformLocation(state->program2, "centre");
check();
#endif
glClearColor ( 0.0, 1.0, 1.0, 1.0 );
glGenBuffers(1, &state->buf);
check();
// Prepare a texture image
glGenTextures(1, &state->tex);
check();
glBindTexture(GL_TEXTURE_2D,state->tex);
check();
// glActiveTexture(0)
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,state->screen_width,state->screen_height,0,GL_RGB,GL_UNSIGNED_SHORT_5_6_5,0);
check();
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
check();
// Prepare a framebuffer for rendering
glGenFramebuffers(1,&state->tex_fb);
check();
glBindFramebuffer(GL_FRAMEBUFFER,state->tex_fb);
check();
glFramebufferTexture2D(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_TEXTURE_2D,state->tex,0);
check();
glBindFramebuffer(GL_FRAMEBUFFER,0);
check();
// Prepare viewport
glViewport ( 0, 0, state->screen_width, state->screen_height );
check();
// Upload vertex data to a buffer
glBindBuffer(GL_ARRAY_BUFFER, state->buf);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data),
vertex_data, GL_STATIC_DRAW);
glVertexAttribPointer(state->attr_vertex, 3, GL_FLOAT, 0, 12, 0);
glEnableVertexAttribArray(state->attr_vertex);
check();
}
static void init_shaders(CUBE_STATE_T *state)
{
static const GLfloat vertex_data[] = {
-1.0,-1.0,1.0,1.0,
1.0,-1.0,1.0,1.0,
1.0,1.0,1.0,1.0,
-1.0,1.0,1.0,1.0
};
const GLchar *vshader_source =
"attribute vec4 vertex;"
"void main(void) {"
" vec4 pos = vertex;"
" gl_Position = pos;"
"}";
const GLchar *fshader_source =
"void main(void) {"
" gl_FragColor = vec4(0,1,0,1);"
"}";
state->vshader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(state->vshader, 1, &vshader_source, 0);
glCompileShader(state->vshader);
check();
if (state->verbose)
showlog(state->vshader);
state->fshader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(state->fshader, 1, &fshader_source, 0);
glCompileShader(state->fshader);
check();
if (state->verbose)
showlog(state->fshader);
state->program = glCreateProgram();
glAttachShader(state->program, state->vshader);
glAttachShader(state->program, state->fshader);
glLinkProgram(state->program);
check();
if (state->verbose)
showprogramlog(state->program);
state->attr_vertex = glGetAttribLocation(state->program, "vertex");
#if 0
state->unif_color = glGetUniformLocation(state->program, "color");
state->unif_scale = glGetUniformLocation(state->program, "scale");
state->unif_offset = glGetUniformLocation(state->program, "offset");
state->unif_tex = glGetUniformLocation(state->program, "tex");
state->unif_centre = glGetUniformLocation(state->program, "centre");
#endif
check();
glClearColor ( 0.0, 1.0, 1.0, 1.0 );
glGenBuffers(1, &state->buf);
check();
// Prepare a texture image
glGenTextures(1, &state->tex);
check();
glBindTexture(GL_TEXTURE_2D,state->tex);
check();
// glActiveTexture(0)
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,state->screen_width,state->screen_height,0,GL_RGB,GL_UNSIGNED_SHORT_5_6_5,0);
check();
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
check();
// Prepare a framebuffer for rendering
glGenFramebuffers(1,&state->tex_fb);
check();
glBindFramebuffer(GL_FRAMEBUFFER,state->tex_fb);
check();
glFramebufferTexture2D(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_TEXTURE_2D,state->tex,0);
check();
glBindFramebuffer(GL_FRAMEBUFFER,0);
check();
// Prepare viewport
glViewport ( 0, 0, state->screen_width, state->screen_height );
check();
// Upload vertex data to a buffer
glBindBuffer(GL_ARRAY_BUFFER, state->buf);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data),
vertex_data, GL_STATIC_DRAW);
glVertexAttribPointer(state->attr_vertex, 4, GL_FLOAT, 0, 16, 0);
glEnableVertexAttribArray(state->attr_vertex);
check();
}
