Beispiel #1
0
int main(void)
{
	//	Engine initialization
	TinyRender::EngineManager engine;
	engine.set_viewport(0, 0, width, height);
	engine.set_depth(width);
	//	TODO: (alxe) simplify api!!
	TinyRender::Vec3f light_vec;
	light_vec[0] = 0.0; light_vec[1] = 0.0; light_vec[2] = -1.0;
	engine.set_light_direction(light_vec);
	//	Shader creation
	std::unique_ptr<TinyRender::Shader> shader = std::make_unique<TinyRender::DummyShader>(engine);

	std::vector<std::vector<int>> z_buffer(height, std::vector<int>(width, std::numeric_limits<int>::min()));
	TinyRender::TGAImage tga_image(width, height, TinyRender::TGAImage::ImageFormat_RGB);
	TinyRender::Model model("../../Models/AfricanHead.obj");
	TinyRender::TGAImage text_map("../../Models/AfricanHeadDiffuse.tga");
	std::ofstream out_tga_file("../../Temp/TGATEST.tga", std::ios::binary);
	
	//	Buffer of screen points
	std::array<TinyRender::Vec3i, 3> screen_points;

	for (size_t tr_id = 0; tr_id < model.triangles().size(); ++tr_id)
	{

		const TinyRender::Vec3f& p1 = model.vertices()[model.triangles()[tr_id].vertices[0]];
		const TinyRender::Vec3f& uv1 = model.uv_vertices()[model.triangles()[tr_id].uv_vertices[0]];
		const TinyRender::Vec3f& p2 = model.vertices()[model.triangles()[tr_id].vertices[1]];
		const TinyRender::Vec3f& uv2 = model.uv_vertices()[model.triangles()[tr_id].uv_vertices[1]];
		const TinyRender::Vec3f& p3 = model.vertices()[model.triangles()[tr_id].vertices[2]];
		const TinyRender::Vec3f& uv3 = model.uv_vertices()[model.triangles()[tr_id].uv_vertices[2]];

		const TinyRender::Vec3i& p1i = engine.transform(p1);
		const TinyRender::Vec3i& p2i = engine.transform(p2);
		const TinyRender::Vec3i& p3i = engine.transform(p3);

		const float u1x  = uv1[0] * text_map.width();
		const float u1y =  uv1[1] * text_map.height();


		const float u2x = uv2[0] * text_map.width();
		const float u2y = uv2[1] * text_map.height();

		const float u3x = uv3[0] * text_map.width();
		const float u3y = uv3[1] * text_map.height();

		TinyRender::Vec3f norm_vec = vector_product((p3 - p1), (p2 - p1));
		norm_vec.normalize();
		const float intense = light_vec * norm_vec;
		if (intense > 0)
		{
			TinyRender::render_triangle(p1i[0], p1i[1], p1i[2], u1x, u1y, 
										p2i[0], p2i[1], p2i[2], u2x, u2y,
										p3i[0], p3i[1], p3i[2], u3x, u3y,
										tga_image, text_map, z_buffer, intense);
		}
	}
	tga_image << out_tga_file;
	out_tga_file.close();
	return 0;
}
Beispiel #2
0
void GUIPlugin::publishMapImage()
{
    // clear image
    map_image_ = cv::Mat(map_image_.rows, map_image_.cols, CV_8UC3, cv::Scalar(10, 10, 10));

    // Draw world model shapes

    cv::Mat z_buffer(map_image_.rows, map_image_.cols, CV_32FC1, 0.0);

    for(ed::WorldModel::const_iterator it_entity = world_model_->begin(); it_entity != world_model_->end(); ++it_entity)
    {
        const ed::EntityConstPtr& e = *it_entity;

        if (e->shape() && e->id() != "floor")
        {
            cv::Scalar color = idToColor(e->id());
            cv::Vec3b color_vec(0.5 * color[0], 0.5 * color[1], 0.5 * color[2]);

            geo::Pose3D pose = projector_pose_.inverse() * e->pose();
            geo::RenderOptions opt;
            opt.setMesh(e->shape()->getMesh(), pose);

            ColorRenderResult res(map_image_, z_buffer, color_vec, projector_pose_.t.z - 3, projector_pose_.t.z + 1);

            // Render
            projector_.render(opt, res);
        }
    }

    for(ed::WorldModel::const_iterator it_entity = world_model_->begin(); it_entity != world_model_->end(); ++it_entity)
    {
        const ed::EntityConstPtr& e = *it_entity;

        const pcl::PointCloud<pcl::PointXYZ>& chull_points = e->convexHull().chull;

        cv::Scalar color = idToColor(e->id());
        int thickness = 1;
        if (selected_id_ == e->id())
            thickness = 3;

        // draw the polygon
        if (!chull_points.empty())
        {
            // Lower polygon
            for(unsigned int i = 0; i < chull_points.size(); ++i)
            {
                int j = (i + 1) % chull_points.size();

                const pcl::PointXYZ& p1 = chull_points[i];
                const pcl::PointXYZ& p2 = chull_points[j];

                cv::line(map_image_,
                         coordinateToPixel(p1.x, p1.y, e->convexHull().min_z),
                         coordinateToPixel(p2.x, p2.y, e->convexHull().min_z),
                         0.3 * color, thickness);
            }

            // Edges in between
            for(unsigned int i = 0; i < chull_points.size(); ++i)
            {
                const pcl::PointXYZ p = chull_points[i];
                cv::line(map_image_,
                         coordinateToPixel(p.x, p.y, e->convexHull().min_z),
                         coordinateToPixel(p.x, p.y, e->convexHull().max_z),
                         0.5 * color, thickness);
            }


            // Upper polygon
            for(unsigned int i = 0; i < chull_points.size(); ++i)
            {
                int j = (i + 1) % chull_points.size();

                const pcl::PointXYZ& p1 = chull_points[i];
                const pcl::PointXYZ& p2 = chull_points[j];

                cv::line(map_image_,
                         coordinateToPixel(p1.x, p1.y, e->convexHull().max_z),
                         coordinateToPixel(p2.x, p2.y, e->convexHull().max_z),
                         color, thickness);
            }

            if (e->type() == "person")
            {

                cv::circle(map_image_, coordinateToPixel(e->convexHull().center_point), 15, cv::Scalar(255, 0, 0), 10);
            }
        }
    }

    // Find the global most recent measurement
    ed::MeasurementConstPtr last_measurement;
    for(ed::WorldModel::const_iterator it_entity = world_model_->begin(); it_entity != world_model_->end(); ++it_entity)
    {
        const ed::EntityConstPtr& e = *it_entity;
        if (e->lastMeasurement() && (!last_measurement || e->lastMeasurement()->timestamp() > e->lastMeasurement()->timestamp()))
            last_measurement = e->lastMeasurement();
    }

    if (last_measurement)
    {
        const geo::Pose3D& sensor_pose = last_measurement->sensorPose();

        // Draw sensor origin
        const geo::Vector3& p = sensor_pose.getOrigin();
        cv::Point2i p_2d = coordinateToPixel(p);

        cv::circle(map_image_, p_2d, 10, cv::Scalar(255, 255, 255));

        rgbd::View view(*last_measurement->image(), 100); // width doesnt matter; we'll go back to world coordinates anyway
        geo::Vector3 p1 = view.getRasterizer().project2Dto3D(0, 0) * 3;
        geo::Vector3 p2 = view.getRasterizer().project2Dto3D(view.getWidth() - 1, 0) * 3;
        geo::Vector3 p3 = view.getRasterizer().project2Dto3D(0, view.getHeight() - 1) * 3;
        geo::Vector3 p4 = view.getRasterizer().project2Dto3D(view.getWidth() - 1, view.getHeight() - 1) * 3;

        cv::Point2i p1_2d = coordinateToPixel(sensor_pose * p1);
        cv::Point2i p2_2d = coordinateToPixel(sensor_pose * p2);
        cv::Point2i p3_2d = coordinateToPixel(sensor_pose * p3);
        cv::Point2i p4_2d = coordinateToPixel(sensor_pose * p4);

        cv::Scalar fustrum_color(100, 100, 100);

        cv::line(map_image_, p_2d, p1_2d, fustrum_color);
        cv::line(map_image_, p_2d, p2_2d, fustrum_color);
        cv::line(map_image_, p_2d, p3_2d, fustrum_color);
        cv::line(map_image_, p_2d, p4_2d, fustrum_color);

        cv::line(map_image_, p1_2d, p2_2d, fustrum_color);
        cv::line(map_image_, p1_2d, p3_2d, fustrum_color);
        cv::line(map_image_, p2_2d, p4_2d, fustrum_color);
        cv::line(map_image_, p3_2d, p4_2d, fustrum_color);
    }

    if (t_last_click_ > ros::Time(0) && t_last_click_ > ros::Time::now() - ros::Duration(1))
    {
        cv::circle(map_image_, p_click_, 20, cv::Scalar(0, 0, 255), 5);
    }

    // Convert to binary
    tue_serialization::Binary msg;
    if (imageToBinary(map_image_, msg.data, IMAGE_COMPRESSION_PNG))
    {
        pub_image_map_.publish(msg);
    }

//    cv::imshow("gui", map_image_);
//    cv::waitKey(3);
}