Beispiel #1
0
 /**
  * Checks, if the an object with shape p_shape and net nos p_net_no_arr and clearance class
  * p_cl_class can be inserted on layer p_layer without clearance violation.
  */
 public boolean check_shape(Area p_shape, int p_layer, int[] p_net_no_arr, int p_cl_class) {
   TileShape[] tiles = p_shape.split_to_convex();
   ShapeSearchTree default_tree = this.search_tree_manager.get_default_tree();
   for (int i = 0; i < tiles.length; ++i) {
     TileShape curr_shape = tiles[i];
     if (!curr_shape.is_contained_in(bounding_box)) {
       return false;
     }
     Set<SearchTreeObject> obstacles = new TreeSet<SearchTreeObject>();
     default_tree.overlapping_objects_with_clearance(
         curr_shape, p_layer, p_net_no_arr, p_cl_class, obstacles);
     for (SearchTreeObject curr_ob : obstacles) {
       boolean is_obstacle = true;
       for (int j = 0; j < p_net_no_arr.length; ++j) {
         if (!curr_ob.is_obstacle(p_net_no_arr[j])) {
           is_obstacle = false;
         }
       }
       if (is_obstacle) {
         return false;
       }
     }
   }
   return true;
 }
Beispiel #2
0
 /** Inserts a component ouline into the board. */
 public ComponentOutline insert_component_outline(
     Area p_area,
     boolean p_is_front,
     Vector p_translation,
     double p_rotation_in_degree,
     int p_component_no,
     FixedState p_fixed_state) {
   if (p_area == null) {
     System.out.println("BasicBoard.insert_component_outline: p_area is null");
     return null;
   }
   if (!p_area.is_bounded()) {
     System.out.println("BasicBoard.insert_component_outline: p_area is not bounded");
     return null;
   }
   ComponentOutline outline =
       new ComponentOutline(
           p_area,
           p_is_front,
           p_translation,
           p_rotation_in_degree,
           p_component_no,
           p_fixed_state,
           this);
   insert_item(outline);
   return outline;
 }
Beispiel #3
0
 /**
  * Returns all items on layer p_layer, which overlap with p_area. If p_layer < 0, the layer is
  * ignored
  */
 public Set<Item> overlapping_items(Area p_area, int p_layer) {
   Set<Item> result = new TreeSet<Item>();
   TileShape[] tile_shapes = p_area.split_to_convex();
   for (int i = 0; i < tile_shapes.length; ++i) {
     Set<SearchTreeObject> curr_overlaps = overlapping_objects(tile_shapes[i], p_layer);
     for (SearchTreeObject curr_overlap : curr_overlaps) {
       if (curr_overlap instanceof Item) {
         result.add((Item) curr_overlap);
       }
     }
   }
   return result;
 }
Beispiel #4
0
 private static void write_conduction_area_scope(
     WriteScopeParameter p_par, board.ConductionArea p_conduction_area)
     throws java.io.IOException {
   int net_count = p_conduction_area.net_count();
   if (net_count <= 0 || net_count > 1) {
     System.out.println("Plane.write_scope: unexpected net count");
     return;
   }
   rules.Net curr_net = p_par.board.rules.nets.get(p_conduction_area.get_net_no(0));
   geometry.planar.Area curr_area = p_conduction_area.get_area();
   int layer_no = p_conduction_area.get_layer();
   board.Layer board_layer = p_par.board.layer_structure.arr[layer_no];
   Layer conduction_layer = new Layer(board_layer.name, layer_no, board_layer.is_signal);
   geometry.planar.Shape boundary_shape;
   geometry.planar.Shape[] holes;
   if (curr_area instanceof geometry.planar.Shape) {
     boundary_shape = (geometry.planar.Shape) curr_area;
     holes = new geometry.planar.Shape[0];
   } else {
     boundary_shape = curr_area.get_border();
     holes = curr_area.get_holes();
   }
   p_par.file.start_scope();
   p_par.file.write("wire ");
   Shape dsn_shape = p_par.coordinate_transform.board_to_dsn(boundary_shape, conduction_layer);
   if (dsn_shape != null) {
     dsn_shape.write_scope(p_par.file, p_par.identifier_type);
   }
   for (int i = 0; i < holes.length; ++i) {
     Shape dsn_hole = p_par.coordinate_transform.board_to_dsn(holes[i], conduction_layer);
     dsn_hole.write_hole_scope(p_par.file, p_par.identifier_type);
   }
   write_net(curr_net, p_par.file, p_par.identifier_type);
   Rule.write_item_clearance_class(
       p_par.board.rules.clearance_matrix.get_name(p_conduction_area.clearance_class_no()),
       p_par.file,
       p_par.identifier_type);
   p_par.file.end_scope();
 }