CameraImageToDisplayImagePass::CameraImageToDisplayImagePass(Poco::Path shader_dir,
osg::ref_ptr<osg::Texture> live_camera_texture,
std::string p2c_filename,
bool UseHDR) :
_live_camera_texture(live_camera_texture), _UseHDR(UseHDR)
{
double scale_width = live_camera_texture->getTextureWidth();
double scale_height = live_camera_texture->getTextureHeight();
osg::ref_ptr<osg::Image> image = load_exr( p2c_filename, _display_width, _display_height, scale_width, scale_height );
_p2c_texture = new osg::Texture2D;
_p2c_texture->setTextureSize( _display_width, _display_height);
_p2c_texture->setInternalFormat(GL_RGB32F);
_p2c_texture->setFilter(osg::Texture2D::MIN_FILTER,osg::Texture2D::LINEAR);
_p2c_texture->setFilter(osg::Texture2D::MAG_FILTER,osg::Texture2D::LINEAR);
_p2c_texture->setImage(image);
create_output_texture();
_camera = new osg::Camera;
setup_camera();
osg::ref_ptr<osg::Group> g = create_input_geometry();
_camera->addChild( g.get() );
_top = new osg::Group;
_top->addDescription("CameraImageToDisplayImagePass top node");
_top->addChild( _camera );
set_shader( shader_dir.absolute().append("CameraImageToDisplayImagePass.vert").toString(),
shader_dir.absolute().append("CameraImageToDisplayImagePass.frag").toString() );
}
ProjectCubemapToGeometryPass::ProjectCubemapToGeometryPass(std::string flyvr_basepath,
osg::TextureCubeMap* texture,
osg::Uniform::Callback* observer_position_cb,
DisplaySurfaceGeometry* geometry_parameters,
unsigned int tex_width,
unsigned int tex_height) :
_geometry_parameters( geometry_parameters), _tex_width(tex_width), _tex_height(tex_height), _observer_position_callback(observer_position_cb)
{
flyvr_assert( texture!=NULL );
flyvr_assert( geometry_parameters!=NULL );
set_flyvr_base_path(flyvr_basepath);
set_plugin_path(flyvr_basepath,false);
_top = new osg::Group;
_top->addDescription("ProjectCubemapToGeometryPass top node");
_in_texture_cubemap = texture;
create_output_texture();
_camera = new osg::Camera;
setup_camera();
_geometry = create_textured_geometry();
_camera->addChild( _geometry.get() );
_top->addChild( _camera );
set_shader( "ProjectCubemapToGeometryPass.vert",
"ProjectCubemapToGeometryPass.frag");
}
carmen_camera_image_t *carmen_camera_start(int argc, char **argv)
{
carmen_camera_image_t *image;
read_parameters(argc, argv);
carmen_warn("Opening camera\n");
camera_fd = open(camera_dev, O_RDONLY | O_NOCTTY);
if (camera_fd < 0)
carmen_die_syserror("Could not open %s as camera device", camera_dev);
check_camera_type();
setup_camera();
image = (carmen_camera_image_t *)calloc(1, sizeof(carmen_camera_image_t));
image->width = image_width;
image->height = image_height;
image->bytes_per_pixel = 3;
image->image_size = image->width*image->height*image->bytes_per_pixel;
image->is_new = 0;
image->timestamp = 0;
image->image = (char *)calloc(image->image_size, sizeof(char));
carmen_test_alloc(image->image);
memset(image->image, 0, image->image_size*sizeof(char));
return image;
}
DWORD PCOCamera::Open(int number)
{
DWORD err =0;
HANDLE camHandle=NULL;
if(getsencamfunc(&camLib)==TRUE)
{
errmsg.ShowError(_T("Cannot load library sencam"));
return PCO_ERROR_APPLICATION_DLLNOTFOUND;
}
strcpy_s(libname,sizeof(libname),CAMLIB_NAME);
err = initboard(number,&camHandle);
errmsg.ShowPCOError(_T("initboard"), err);
if(err == PCO_NOERROR)
{
boardnum=number;
cameraHandle=camHandle;
}
err = setup_camera(camHandle);
errmsg.ShowPCOError(_T("setup_camera"), err);
if(err != PCO_NOERROR)
Close();
else
err=get_cam_param(camHandle,&campar);
if(err == PCO_NOERROR)
SetDefaultValues();
return err;
}
int main(int argc, char** argv) {
char glutGamemode[32];
glutInit(&argc, argv);
setup_camera();
setup_marker();
init_voxels_hp();
// Set up GL context(s) for OpenGL to draw into.
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(prefWidth, prefHeight);
camera_win_id = glutCreateWindow("Camera");
glutTimerFunc(10, TimeEvent, 1);
ARGL_CONTEXT_SETTINGS_REF argl_context_ref = NULL;
// Setup argl library for current context.
if ((argl_context_ref = arglSetupForCurrentContext()) == NULL) {
std::cout << "main(): arglSetupForCurrentContext() returned error." << std::endl;
exit(-1);
}
arUtilTimerReset();
glEnable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
glClearColor(0.0, 0.0, 0.0, 1.0);
glutVisibilityFunc(visibility_camera);
glutIdleFunc(idle_camera);
glutDisplayFunc(display_camera);
glutReshapeFunc(reshape);
glutKeyboardFunc(debug_only);
setup_voxels();
camera_set_context(argl_context_ref);
viewer_win_id = glutCreateWindow("Viewer");
glEnable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
glClearColor(0.0,0.0,0.0,1.0);
glutVisibilityFunc(visibility_viewer);
glutIdleFunc(idle_viewer);
glutDisplayFunc(display_viewer);
glutReshapeFunc(reshape_viewer);
auto voxel_t = std::thread(voxel_carving_routine);
auto capture_t = std::thread(image_capturing_routine);
auto should_capture_t = std::thread(should_capture_routine);
auto a_cam_buffer_t = std::thread(transfer);
voxel_t.detach();
capture_t.detach();
should_capture_t.detach();
a_cam_buffer_t.detach();
glutMainLoop();
return 0;
}
void Canvas::UpdateCamera()
{
auto u = glm::vec3(viewMat[0][0], viewMat[0][1], viewMat[0][2]);
auto v = glm::vec3(viewMat[1][0], viewMat[1][1], viewMat[1][2]);
auto w = glm::vec3(viewMat[2][0], viewMat[2][1], viewMat[2][2]);
auto pos = w * eyeDist - u * cameraTranslate.x - v * cameraTranslate.y;
camera.Setup(pos, u, v, w, fov, apeture, focalLength, exposure, WIDTH, HEIGHT);
setup_camera(camera);
}
TexturedGeometryToCameraImagePass::TexturedGeometryToCameraImagePass(
osg::ref_ptr<osg::Group> textured_geometry,
CameraModel* camera_model) :
_camera_model(camera_model), _textured_geometry(textured_geometry)
{
_top = new osg::Group;
_top->addDescription("TexturedGeometryToCameraImagePass top group");
create_output_texture();
_camera = new osg::Camera;
setup_camera();
_camera->addChild( _textured_geometry.get() );
_top->addChild( _camera );
}
static void
cheese_widget_realize (GtkWidget *widget)
{
CheeseWidgetPrivate *priv = CHEESE_WIDGET_GET_PRIVATE (widget);
GTK_WIDGET_CLASS (cheese_widget_parent_class)->realize (widget);
gtk_spinner_start (GTK_SPINNER (priv->spinner));
gtk_widget_realize (priv->screen);
setup_camera (CHEESE_WIDGET (widget));
gtk_widget_set_app_paintable (priv->problem, TRUE);
gtk_widget_realize (priv->problem);
return;
}
ProjectCubemapToGeometryPass::ProjectCubemapToGeometryPass(std::string freemoovr_basepath,
osg::TextureCubeMap* texture,
osg::Uniform::Callback* observer_position_cb,
DisplaySurfaceGeometry* geometry_parameters,
unsigned int tex_width,
unsigned int tex_height) :
_geometry_parameters( geometry_parameters), _tex_width(tex_width), _tex_height(tex_height), _observer_position_callback(observer_position_cb)
{
freemoovr_assert( texture!=NULL );
freemoovr_assert( geometry_parameters!=NULL );
set_freemoovr_base_path(freemoovr_basepath);
_top = new osg::Group;
_top->addDescription("ProjectCubemapToGeometryPass top node");
_in_texture_cubemap = texture;
_observerPositionUniform = new osg::Uniform( "ObserverPosition",
osg::Vec3(0.22f, 0.22f, 0.9f) );
if (_observer_position_callback!=NULL) {
_observerPositionUniform->setUpdateCallback(_observer_position_callback);
}
create_output_texture();
_camera = new osg::Camera;
setup_camera();
_private_geometry = create_textured_geometry();
_camera->addChild( _private_geometry.get() );
_top->addChild( _camera );
_state_set = _private_geometry->getOrCreateStateSet();
_state_set->addUniform(_observerPositionUniform);
_program = set_shader( _state_set,
"ProjectCubemapToGeometryPass.vert",
"ProjectCubemapToGeometryPass.frag");
_public_geometry = new osg::Group;
_public_geometry->addDescription("ProjectCubemapToGeometryPass output textured geometry top node");
_inner_geode = _create_textured_geometry_inner_geode();
_public_geometry->addChild(_inner_geode.get());
}
void render(void)
{
static GLint iFrames = 0;
static GLfloat fps = 0.0f, DeltaT;
static char cBuffer[64];
struct timeval tv;
GLuint model_id;
// Update timer
gettimeofday(&tv, NULL);
etime = (double)tv.tv_sec + tv.tv_usec / 1000000.0f;
dt = etime - t0;
t0 = etime;
/*
* Make the shadow pass
*
*/
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, FBO );
glPushMatrix();
//Compute light position
sinE = sinf(eLit);
cosE = cosf(eLit);
sinA = sinf(aLit);
cosA = cosf(aLit);
lightPos[0] = lightRadius * cosE * sinA;
lightPos[1] = lightRadius * sinE;
lightPos[2] = lightRadius * cosE * cosA;
lightPos[3] = 1.0f;
//Set light position
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
//Set up camera to light location
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective( 70.0f, 1.0f, 75.0f, 350.0f );
glGetDoublev(GL_PROJECTION_MATRIX, lightProjection );
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt( lightPos[0], lightPos[1], lightPos[2],
0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f );
glGetDoublev(GL_MODELVIEW_MATRIX, lightModelview );
glViewport( 0, 0, shadow_sz, shadow_sz );
glClear(GL_DEPTH_BUFFER_BIT);
glEnable(GL_POLYGON_OFFSET_FILL);
glShadeModel(GL_FLAT);
//Rotate scene, if required
glRotatef(xRot, 1.0f, 0.0f, 0.0f);
glRotatef(yRot, 0.0f, 1.0f, 0.0f);
//Disable shaders
glUseProgramObjectARB(0);
glDisable(GL_VERTEX_PROGRAM_ARB);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
// Draw dynamic objects
for (model_id = 0; model_id < NUM_MODELS; model_id++ )
{
//Update the kinematic's state
UpdateMD2(md2_model[model_id], dt);
//Animate the MD2 models
AnimateMD2(md2_model[model_id], dt);
//Draw the geometry
glPushMatrix();
glTranslatef( md2_model[model_id]->position.x,
md2_model[model_id]->position.y,
md2_model[model_id]->position.z );
glRotatef( md2_model[model_id]->rotation, 0.0f, 1.0f, 0.0f );
DrawMD2(md2_model[model_id]);
glPopMatrix();
}
glPopMatrix();
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
/*
* And now the normal pass
*
*/
//Back to normal settings
glDisable(GL_POLYGON_OFFSET_FILL);
glShadeModel(GL_SMOOTH);
change_size( width, height );
// Clear the window with current clearing color
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
//Set up camera location and parameters
setup_camera((float)dt);
//Retrieve modelview matrix and invert it
glGetDoublev(GL_MODELVIEW_MATRIX, cameraModelview );
FastInvert4( cameraModelview, cameraModelviewInverse );
//Set up depth texture
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, shadow_tx);
//Set up texture matrix for shadow map projection
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glTranslatef(0.5f, 0.5f, 0.5f);
glScalef(0.5f, 0.5f, 0.5f);
glMultMatrixd(lightProjection);
glMultMatrixd(lightModelview);
glMultMatrixd(cameraModelviewInverse);
glMatrixMode(GL_MODELVIEW);
//Rotate scene
glRotatef(xRot, 1.0f, 0.0f, 0.0f);
glRotatef(yRot, 0.0f, 1.0f, 0.0f);
//Re-enable shaders
glEnable(GL_VERTEX_PROGRAM_ARB);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
if (GLSLshader)
glUseProgramObjectARB(progObj);
else
glUseProgramObjectARB(0);
//Floor
//Color
glColor3f(0.64f, 0.63f, 0.65f);
//Set textures
glActiveTexture(GL_TEXTURE0); //Diffuse map
glBindTexture(GL_TEXTURE_2D, texture_id[NUM_TEXTURES-2]);
glActiveTexture(GL_TEXTURE1); //Normal map
glBindTexture(GL_TEXTURE_2D, texture_id[NUM_TEXTURES-1]);
//Set Tangent vector
glVertexAttrib3fv( tangent, floorT );
//Set Binormal vector
glVertexAttrib3fv( binormal, floorB );
//Set Normal vector
glNormal3fv( floorN );
//Call Display List to draw
glCallList(FList);
// Draw dynamic objects
for (model_id = 0; model_id < NUM_MODELS; model_id++ )
{
//Set color
glColor3f( md2_model[model_id]->color.x,
md2_model[model_id]->color.y,
md2_model[model_id]->color.z );
//Set texture
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture_id[2*model_id]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texture_id[2*model_id+1]);
//Draw the geometry
glPushMatrix();
glTranslatef( md2_model[model_id]->position.x,
md2_model[model_id]->position.y,
md2_model[model_id]->position.z );
glRotatef( md2_model[model_id]->rotation, 0.0f, 1.0f, 0.0f );
DrawMD2(md2_model[model_id]);
glPopMatrix();
}
glPopMatrix();
iFrames++;
DeltaT = (GLfloat)(etime-t1);
if( DeltaT >= Timed )
{
fps = (GLfloat)(iFrames)/DeltaT;
fps_count++;
fps_mean = ((fps_count - 1.0f) * fps_mean + fps ) / fps_count;
iFrames = 0;
t1 = etime;
sprintf(cBuffer,"FPS: %.1f Mean FPS: %.1f Poly Scale: %.1f Bias: %.1f", fps, fps_mean, scalePoly, biasPoly);
}
if (print_fps)
{
if (windowpos)
{
glColor3f(1.0f, 1.0f, 1.0f);
glPushAttrib(GL_LIST_BIT);
glListBase(fps_font - ' ');
glWindowPos2i(0,2);
glCallLists(strlen(cBuffer), GL_UNSIGNED_BYTE, cBuffer);
glPopAttrib();
}
if( iFrames == 0 )
printf("FPS: %.1f Mean FPS: %.1f\n", fps, fps_mean);
}
lCam = 0.0f;
vCam = 0.0f;
dCam = 0.0f;
}
void
draw_scene(void)
{
// clear the draw buffer
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
if (show_raytraced)
{
if (needs_rerender)
{
// clear the framebuffer
memset(framebuffer, 255, 3*framebuffer_width*framebuffer_height);
// trace a new picture
ray_trace();
needs_rerender = 0;
}
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Draw the framebuffer using a textured quad
glOrtho(0, framebuffer_width, 0, framebuffer_height, -1, 1);
glDisable(GL_LIGHTING);
glDisable(GL_CULL_FACE);
glEnable(GL_TEXTURE_2D);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,
framebuffer_width, framebuffer_height,
0, GL_RGB, GL_UNSIGNED_BYTE, framebuffer);
glColor3f(1, 1, 1);
glBegin(GL_QUADS);
glTexCoord2i(0, 0);
glVertex2i(0, framebuffer_height);
glTexCoord2i(0, 1);
glVertex2i(0, 0);
glTexCoord2i(1, 1);
glVertex2i(framebuffer_width, 0);
glTexCoord2i(1, 0);
glVertex2i(framebuffer_width, framebuffer_height);
glEnd();
}
else
{
// Draw scene using OpenGL
//glutSetWindowTitle("OpenGL view");
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(VFOV, 1.0*framebuffer_width/framebuffer_height, 0.1, 1000.0);
glMatrixMode(GL_MODELVIEW);
setup_camera();
glEnable(GL_LIGHTING);
glEnable(GL_CULL_FACE);
glDisable(GL_TEXTURE_2D);
// Try to set up the lighting to match the scene
GLfloat v[4];
v[0] = scene_ambient_light;
v[1] = scene_ambient_light;
v[2] = scene_ambient_light;
v[3] = 1.0;
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, v);
for (int l = 0; l < scene_num_lights; l++)
{
glEnable(GL_LIGHT0 + l);
v[0] = scene_lights[l].position.x;
v[1] = scene_lights[l].position.y;
v[2] = scene_lights[l].position.z;
v[3] = 1.0; // we want a positional light source
glLightfv(GL_LIGHT0 + l, GL_POSITION, v);
v[0] = v[1] = v[2] = v[3] = 0.0;
glLightfv(GL_LIGHT0 + l, GL_AMBIENT, v);
glLightfv(GL_LIGHT0 + l, GL_SPECULAR, v);
v[0] = v[1] = v[2] = scene_lights[l].intensity;
v[3] = 1.0;
glLightfv(GL_LIGHT0 + l, GL_DIFFUSE, v);
}
GLfloat one[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat zero[] = { 0.0, 0.0, 0.0, 1.0 };
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, zero);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, zero);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, one);
// Draw the triangles in the scene
triangle tri;
int p, q, r;
glBegin(GL_TRIANGLES);
for (int t = 0; t < scene_num_triangles; t++)
{
tri = scene_triangles[t];
p = tri.v[0];
q = tri.v[1];
r = tri.v[2];
glNormal3f(tri.vn[0].x, tri.vn[0].y, tri.vn[0].z);
glVertex3f(scene_vertices[p].x, scene_vertices[p].y, scene_vertices[p].z);
glNormal3f(tri.vn[1].x, tri.vn[1].y, tri.vn[1].z);
glVertex3f(scene_vertices[q].x, scene_vertices[q].y, scene_vertices[q].z);
glNormal3f(tri.vn[2].x, tri.vn[2].y, tri.vn[2].z);
glVertex3f(scene_vertices[r].x, scene_vertices[r].y, scene_vertices[r].z);
}
glEnd();
if (show_normals)
{
// Draw vertex normals as red lines
glDisable(GL_LIGHTING);
glColor3f(1, 0, 0);
glBegin(GL_LINES);
vec3 n;
for (int t = 0; t < scene_num_triangles; t++)
{
tri = scene_triangles[t];
for (int vi = 0; vi < 3; vi++)
{
p = tri.v[vi];
n = scene_vertices[p];
glVertex3f(n.x, n.y, n.z);
n = v3_add(n, v3_multiply(tri.vn[vi], 0.05));
glVertex3f(n.x, n.y, n.z);
}
}
glEnd();
glEnable(GL_LIGHTING);
}
// Draw the spheres in the scene
for (int s = 0; s < scene_num_spheres; s++)
{
glPushMatrix();
glTranslatef(scene_spheres[s].center.x, scene_spheres[s].center.y, scene_spheres[s].center.z);
glutSolidSphere(scene_spheres[s].radius, 12, 12);
glPopMatrix();
}
// Show BVH node bboxes
if (show_bvh)
{
glDisable(GL_LIGHTING);
if (draw_bvh_mode == 0)
draw_bvh_leaf_nodes(bvh_root);
else
draw_bvh_inner_nodes(1, bvh_root);
}
/*
// Draw some axes
glDisable(GL_LIGHTING);
glBegin(GL_LINES);
glColor3f(1, 0, 0);
glVertex3f(0, 0, 0);
glVertex3f(10, 0, 0);
glColor3f(0, 1, 0);
glVertex3f(0, 0, 0);
glVertex3f(0, 10, 0);
glColor3f(0, 0, 1);
glVertex3f(0, 0, 0);
glVertex3f(0, 0, 10);
glEnd();
*/
}
// finally, swap the draw buffers to make the triangles appear on screen
glutSwapBuffers();
}
int main(int argc, char** argv) {
PORT_USERDATA userdata;
MMAL_STATUS_T status;
cairo_surface_t *surface,*surface2;
cairo_t *context,*context2;
int i;
int duration = 1;
int valid = 1;
char text[256];
strcpy (text,"Camera 1");
for (i = 1; i < argc && valid; i++)
{
if (strcmp(argv[i], "-s")==0) {
strcpy(text, argv[i + 1]);
i++;
}
if (strcmp(argv[i], "-t")==0) {
sscanf(argv[i + 1], "%u", &duration);
i++;
}
if (strcmp(argv[i], "-d")==0) {
}
}
//fprintf(stderr, "CAPTION : %s\n", text);
duration = 3;
memset(&userdata, 0, sizeof (PORT_USERDATA));
userdata.width = VIDEO_WIDTH;
userdata.height = VIDEO_HEIGHT;
userdata.fps = 0.0;
//fprintf(stderr, "VIDEO_WIDTH : %i\n", userdata.width );
//fprintf(stderr, "VIDEO_HEIGHT: %i\n", userdata.height );
//fprintf(stderr, "VIDEO_FPS : %i\n", VIDEO_FPS);
//fprintf(stderr, "Running...\n");
bcm_host_init();
surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 600, 100);
context = cairo_create(surface);
cairo_rectangle(context, 0.0, 0.0, 600, 100);
cairo_set_source_rgba(context, 0.0, 0.0, 0.0, 1.0);
cairo_fill(context);
userdata.overlay_buffer = cairo_image_surface_get_data(surface);
userdata.overlay = 1;
surface2 = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 600, 100);
context2 = cairo_create(surface2);
cairo_rectangle(context2, 0.0, 0.0, 600, 100);
cairo_set_source_rgba(context2, 0.0, 0.0, 0.0, 1.0);
cairo_fill(context2);
userdata.overlay_buffer2 = cairo_image_surface_get_data(surface2);
if (1 && setup_camera(&userdata) != 0) {
fprintf(stderr, "Error: setup camera %x\n", status);
return -1;
}
if (1 && setup_encoder(&userdata) != 0) {
fprintf(stderr, "Error: setup encoder %x\n", status);
return -1;
}
if (1 && setup_preview(&userdata) != 0) {
fprintf(stderr, "Error: setup preview %x\n", status);
return -1;
}
while (duration >0) {
//Update Draw to unused buffer that way there is no flickering of the overlay text if the overlay update rate
//and video FPS are not the same
if (userdata.overlay == 1) {
cairo_rectangle(context, 0.0, 0.0, 600, 100);
cairo_set_source_rgba(context, 0.0, 0.0, 0.0, 1.0);
cairo_fill(context);
cairo_move_to(context, 0.0, 0.0);
cairo_set_source_rgba(context, 1.0, 1.0, 1.0, 1.0);
cairo_move_to(context, 0.0, 30.0);
cairo_set_font_size(context, 20.0);
//sprintf(text, "%.2fFPS GPS: %.3f, %.3f Speed %.1fkm/h b0", userdata.fps,lat,lon,speed);
cairo_show_text(context, text);
userdata.overlay = 0;
}
else {
cairo_rectangle(context2, 0.0, 0.0, 600, 100);
cairo_set_source_rgba(context2, 0.0, 0.0, 0.0, 1.0);
cairo_fill(context2);
cairo_move_to(context2, 0.0, 0.0);
cairo_set_source_rgba(context2, 1.0, 1.0, 1.0, 1.0);
cairo_move_to(context2, 0.0, 30.0);
cairo_set_font_size(context2, 20.0);
//sprintf(text, "%.2fFPS GPS: %.3f, %.3f Speed %.1fkm/h b1", userdata.fps,lat,lon,speed);
//sprintf(text, "%.2fFPS GPS: 0.00000, 0.00000 Speed 0km/h b1", userdata.fps);
cairo_show_text(context2, text);
userdata.overlay = 1;
}
duration--;
usleep(30000);
}
return 0;
}
// ------------------------------------------------------------------------------------------------------------------------------------------------
//
int main(int argc, char** argv)
{
PORT_USERDATA userdata;
MMAL_STATUS_T status;
memset(&userdata, 0, sizeof (PORT_USERDATA));
userdata.width = VIDEO_WIDTH;
userdata.height = VIDEO_HEIGHT;
userdata.motion = 0;
userdata.grabframe = 1;
fprintf(stderr, "VIDEO_WIDTH : %i\n", userdata.width );
fprintf(stderr, "VIDEO_HEIGHT: %i\n", userdata.height );
fprintf(stderr, "VIDEO_FPS : %i\n", VIDEO_FPS);
bcm_host_init();
if (1 && setup_camera(&userdata) != 0) {
fprintf(stderr, "Error: setup camera %x\n", status);
return -1;
}
if (1 && setup_encoder(&userdata) != 0) {
fprintf(stderr, "Error: setup encoder %x\n", status);
return -1;
}
vcos_semaphore_create(&userdata.complete_semaphore, "mmal_opencv_video", 0);
int count = 0;
int opencv_frames = 0;
struct timespec t1;
struct timespec t2;
clock_gettime(CLOCK_MONOTONIC, &t1);
struct timespec s;
s.tv_sec = 0;
s.tv_nsec = 30000000;
int nTotalFrameCount = VIDEO_FPS * 30;
userdata.motion = nTotalFrameCount;
unsigned dwTickCount_Start = GetTickCount( );
while (1)
{
nanosleep(&s, NULL);
if (userdata.motion == 0)
{
break;
}
opencv_frames++;
if( (CALC_FPS) && (opencv_frames % (VIDEO_FPS*2) == 0) ){
fprintf(stderr, "FPS: Video = %.2f\n", userdata.video_fps);
}
}
unsigned dwTickCount_End = GetTickCount( );
fprintf( stderr, "%d frames were stored in %dms -> %.2f fps\n", nTotalFrameCount, (dwTickCount_End - dwTickCount_Start), nTotalFrameCount / ((dwTickCount_End - dwTickCount_Start) / 1000.0) );
return 0;
}
int main(int argc, char** argv) {
PORT_USERDATA userdata;
MMAL_STATUS_T status;
cairo_surface_t *surface,*surface2;
cairo_t *context,*context2;
memset(&userdata, 0, sizeof (PORT_USERDATA));
userdata.width = VIDEO_WIDTH;
userdata.height = VIDEO_HEIGHT;
userdata.fps = 0.0;
fprintf(stderr, "VIDEO_WIDTH : %i\n", userdata.width );
fprintf(stderr, "VIDEO_HEIGHT: %i\n", userdata.height );
fprintf(stderr, "VIDEO_FPS : %i\n", VIDEO_FPS);
fprintf(stderr, "Running...\n");
bcm_host_init();
surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 600, 100);
context = cairo_create(surface);
cairo_rectangle(context, 0.0, 0.0, 600, 100);
cairo_set_source_rgba(context, 0.0, 0.0, 0.0, 1.0);
cairo_fill(context);
userdata.overlay_buffer = cairo_image_surface_get_data(surface);
userdata.overlay = 1;
surface2 = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 600, 100);
context2 = cairo_create(surface2);
cairo_rectangle(context2, 0.0, 0.0, 600, 100);
cairo_set_source_rgba(context2, 0.0, 0.0, 0.0, 1.0);
cairo_fill(context2);
userdata.overlay_buffer2 = cairo_image_surface_get_data(surface2);
if (1 && setup_camera(&userdata) != 0) {
fprintf(stderr, "Error: setup camera %x\n", status);
return -1;
}
if (1 && setup_encoder(&userdata) != 0) {
fprintf(stderr, "Error: setup encoder %x\n", status);
return -1;
}
if (1 && setup_preview(&userdata) != 0) {
fprintf(stderr, "Error: setup preview %x\n", status);
return -1;
}
char text[256];
//fake Speed and GPS data
float lat = 47.4912;
float lon = 8.906;
float speed = 20.0;
while (1) {
//Update Draw to unused buffer that way there is no flickering of the overlay text if the overlay update rate
//and video FPS are not the same
if (userdata.overlay == 1) {
cairo_rectangle(context, 0.0, 0.0, 600, 100);
cairo_set_source_rgba(context, 0.0, 0.0, 0.0, 1.0);
cairo_fill(context);
cairo_move_to(context, 0.0, 0.0);
cairo_set_source_rgba(context, 1.0, 1.0, 1.0, 1.0);
cairo_move_to(context, 0.0, 30.0);
cairo_set_font_size(context, 20.0);
sprintf(text, "%.2fFPS GPS: %.3f, %.3f Speed %.1fkm/h b0", userdata.fps,lat,lon,speed);
cairo_show_text(context, text);
userdata.overlay = 0;
}
else {
cairo_rectangle(context2, 0.0, 0.0, 600, 100);
cairo_set_source_rgba(context2, 0.0, 0.0, 0.0, 1.0);
cairo_fill(context2);
cairo_move_to(context2, 0.0, 0.0);
cairo_set_source_rgba(context2, 1.0, 1.0, 1.0, 1.0);
cairo_move_to(context2, 0.0, 30.0);
cairo_set_font_size(context2, 20.0);
sprintf(text, "%.2fFPS GPS: %.3f, %.3f Speed %.1fkm/h b1", userdata.fps,lat,lon,speed);
//sprintf(text, "%.2fFPS GPS: 0.00000, 0.00000 Speed 0km/h b1", userdata.fps);
cairo_show_text(context2, text);
userdata.overlay = 1;
}
lat += 0.01;
lon += 0.01;
speed += 0.1;
usleep(30000);
}
return 0;
}
