void increase_triangle_show(increase_triangle_t *increase_triangle)
{
	increase_triangle_t *p_increase_triangle=increase_triangle;
	if(NULL==p_increase_triangle){
		return;
	}
	int i=0;
	int layer_value_sum=0;
	int layers_value_sum=0;
	int all_value_sum=0;
	printf("\n");
	printf("layers=[%d],base_value=[%d],multiple=[%d];\n",get_layers(p_increase_triangle),get_base_value(p_increase_triangle),get_multiple(p_increase_triangle));
	show_layer_index(p_increase_triangle->layer_index);
	printf("\n");
	
	for(i=0; i<p_increase_triangle->layers; i++){
		layer_value_sum=get_layer_value_sum(p_increase_triangle,i+1);		
		layers_value_sum=get_increase_triangle_layers_value_sum(p_increase_triangle,i+1);
		printf("layer=%-2d,layer_sum=[%-5d] 2*layer_sum=[%-5d];layers_sum=[%-5d],2*layer_sum-layers_num=[%-5d]\n",i+1,layer_value_sum,2*layer_value_sum,layers_value_sum,2*layer_value_sum-layers_value_sum);
			
	}
	printf("\n");

	all_value_sum=get_increase_triangle_all_value_sum(p_increase_triangle);
	printf("all layers sum=[%-5d]\n", all_value_sum);
	printf("\n");
	
	return;
}
void
pms::serialization::spritedesc::node_parser_sprite_declaration
::get_layers_and_size
( const resources::image& image, layout::atlas_page::sprite& s,
  const tree_node& size_node, const tree_node& layer_list_node ) const
{
  tree_node key_node;

  if ( size_node.children.empty() )
    key_node = size_node;
  else
    key_node = size_node.children[0];
  
  const std::string key( key_node.value.begin(), key_node.value.end() );
  
  if ( key == "autosize" )
    {
      s.layers = get_layers( image, layer_list_node );
      compute_source_box( s );
    }
  else
    {
      if ( key == "image_size" )
          s.source_box.set( 0, 0, image.width, image.height );
      else // key is the name of a layer
        {
          resources::layer layer;
          get_layer_info( image, layer, key );

          s.source_box.set( layer.x, layer.y, layer.width, layer.height );
        }

      s.layers = get_layers( image, layer_list_node );
    }

  crop_sprite_to_image_bounds( image, s );

  if ( size_node.children.empty() )
    apply_result_box_ratio( s, 1 );
  else
    apply_result_box_ratio( s, size_node.children[ 1 ] );
}
示例#3
0
LayerSharedPtr MLNetwork::add_layer(const std::string& name, bool directed) {
	LayerSharedPtr check = get_layer(name);
	if (check) return NULL;
	layer_id id = ++max_layer_id;
	LayerSharedPtr layer_ptr(new layer(id,name));
	layers.insert(id,layer_ptr);
	cidx_layer_by_name[name] = layer_ptr;
	for (LayerSharedPtr layer : get_layers()) {
		sidx_edges_by_layer_pair[layer->id][layer_ptr->id]; // initialize an empty map
	}
	set_directed(layer_ptr,layer_ptr,directed);
	return layer_ptr;
}
void pms::serialization::spritedesc::node_parser_sprite_declaration::parse_node
( const resources::image_mapping& images, layout::atlas_page& desc,
  const tree_node& node ) const
{
  layout::atlas_page::sprite s;
  s.bleed = false;

  std::size_t n( 0 );

  if ( ( node.children[n].value.id() == grammar::id_properties )
       || ( node.children[n].value.id() == grammar::id_identifier ) )
      apply_sprite_properties( s, node.children[ n++ ] );

  const tree_node name_node( node.children[n++] );
  const tree_node size_node( node.children[n++] );
  const tree_node image_node( node.children[n++] );
  const tree_node layers_node( node.children[n++] );
  
  get_sprite_name( s, name_node );

  if ( desc.get_sprite_by_name(s.name) != desc.sprite_end() )
    std::cerr << "warning: duplicate sprite entry '" << s.name << "'."
              << std::endl;

  get_image_id( s, image_node );

  boost::optional< const resources::image& > image
    ( get_image_from_id( images, desc, s.image_id ) );

  if ( !image )
    return;
  
  get_layers_and_size( *image, s, size_node, layers_node );

  if ( n < node.children.size() )
    s.mask = get_layers( *image, node.children[n++] );

  desc.add_sprite( s );
}
carmen_velodyne_partial_scan_message
carmen_laser_ldmrs_convert_laser_scan_to_partial_velodyne_message(carmen_laser_ldmrs_message *msg, double laserscan_timestamp)
{
	carmen_velodyne_partial_scan_message velodyne_message;

	int layer_1_start, layer_1_size, layer_2_start, layer_2_size,
		layer_3_start, layer_3_size, layer_4_start, layer_4_size;

	get_layers(msg, layer_1_start, layer_1_size, layer_2_start, layer_2_size,
					layer_3_start, layer_3_size, layer_4_start, layer_4_size);

	double layer_1_start_angle = msg->arraypoints[layer_1_start].horizontal_angle;
	double layer_1_end_angle = msg->arraypoints[layer_1_start + layer_1_size - 1].horizontal_angle;
	double layer_2_start_angle = msg->arraypoints[layer_2_start].horizontal_angle;
	double layer_2_end_angle = msg->arraypoints[layer_2_start + layer_2_size - 1].horizontal_angle;
	double layer_3_start_angle = msg->arraypoints[layer_3_start].horizontal_angle;
	double layer_3_end_angle = msg->arraypoints[layer_3_start + layer_3_size - 1].horizontal_angle;
	double layer_4_start_angle = msg->arraypoints[layer_4_start].horizontal_angle;
	double layer_4_end_angle = msg->arraypoints[layer_4_start + layer_4_size - 1].horizontal_angle;

	double largest_angle12 = (layer_1_start_angle > layer_2_start_angle) ? layer_1_start_angle: layer_2_start_angle;
	double largest_angle34 = (layer_3_start_angle > layer_4_start_angle) ? layer_3_start_angle: layer_4_start_angle;
	double largest_angle = (largest_angle12 > largest_angle34) ? largest_angle12: largest_angle34;

	double smallest_angle12 = (layer_1_end_angle < layer_2_end_angle) ? layer_1_end_angle: layer_2_end_angle;
	double smallest_angle34 = (layer_3_end_angle < layer_4_end_angle) ? layer_3_end_angle: layer_4_end_angle;
	double smallest_angle = (smallest_angle12 < smallest_angle34) ? smallest_angle12: smallest_angle34;

	double half_a_degree = carmen_degrees_to_radians(0.5);
	int number_of_shots = (int) ((largest_angle - smallest_angle) / half_a_degree);

	velodyne_message.number_of_32_laser_shots = number_of_shots;
	velodyne_message.partial_scan = (carmen_velodyne_32_laser_shot *) calloc (velodyne_message.number_of_32_laser_shots, sizeof(carmen_velodyne_32_laser_shot));
	velodyne_message.timestamp = laserscan_timestamp;
	velodyne_message.host = carmen_get_host();

	for (int i = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0; i < velodyne_message.number_of_32_laser_shots; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			velodyne_message.partial_scan[i].distance[j] = 0;
			velodyne_message.partial_scan[i].intensity[j] = 255;
		}

		double angle = largest_angle - ((double) i) * half_a_degree - 0.000005;
		velodyne_message.partial_scan[i].angle = -carmen_radians_to_degrees(angle);

		if ((angle <= msg->arraypoints[layer_1_start + i1].horizontal_angle) &&
			(angle >= layer_1_end_angle))
		{
			double distance = msg->arraypoints[layer_1_start + i1].radial_distance;
			distance = (distance > 130.0)? 0.0: distance; // larger than 130 meters does no fit an unsigned short int distance field of Velodyne...
			velodyne_message.partial_scan[i].distance[0] = (unsigned short) (round(distance * 500.0));
			velodyne_message.partial_scan[i].intensity[0] = 255;
			i1++;
		}

		if ((angle <= msg->arraypoints[layer_2_start + i2].horizontal_angle) &&
			(angle >= layer_2_end_angle))
		{
			double distance = msg->arraypoints[layer_2_start + i2].radial_distance;
			distance = (distance > 130.0)? 0.0: distance; // larger than 130 meters does no fit an unsigned short int distance field of Velodyne...
			velodyne_message.partial_scan[i].distance[1] = (unsigned short) (round(distance * 500.0));
			velodyne_message.partial_scan[i].intensity[1] = 255;
			i2++;
		}

		if ((angle <= msg->arraypoints[layer_3_start + i3].horizontal_angle) &&
			(angle >= layer_3_end_angle))
		{
			double distance = msg->arraypoints[layer_3_start + i3].radial_distance;
			distance = (distance > 130.0)? 0.0: distance; // larger than 130 meters does no fit an unsigned short int distance field of Velodyne...
			velodyne_message.partial_scan[i].distance[2] = (unsigned short) (round(distance * 500.0));
			velodyne_message.partial_scan[i].intensity[2] = 255;
			i3++;
		}

		if ((angle <= msg->arraypoints[layer_4_start + i4].horizontal_angle) &&
			(angle >= layer_4_end_angle))
		{
			double distance = msg->arraypoints[layer_4_start + i4].radial_distance;
			distance = (distance > 130.0)? 0.0: distance; // larger than 130 meters does no fit an unsigned short int distance field of Velodyne...
			velodyne_message.partial_scan[i].distance[3] = (unsigned short) (round(distance * 500.0));
			velodyne_message.partial_scan[i].intensity[3] = 255;
			i4++;
		}
	}

	return (velodyne_message);
}
示例#6
0
std::string MLNetwork::to_string() const {
	return "Multilayer Network (\"" + name + "\": " + std::to_string(get_layers().size()) + " layers, " +
			std::to_string(get_actors().size()) + " actors, " +
			std::to_string(get_nodes().size()) + " nodes, " +
			std::to_string(get_edges().size()) + " edges)";
}