Esempio n. 1
0
 /**
  * Looks if at the input position ends a trace with the input net number, which has no normal
  * contact at that position. Returns null, if no tail is found.
  */
 public Trace get_trace_tail(Point p_location, int p_layer, int[] p_net_no_arr) {
   TileShape point_shape = TileShape.get_instance(p_location);
   Collection<SearchTreeObject> found_items = overlapping_objects(point_shape, p_layer);
   Iterator<SearchTreeObject> it = found_items.iterator();
   while (it.hasNext()) {
     SearchTreeObject curr_ob = it.next();
     if (curr_ob instanceof Trace) {
       Trace curr_trace = (Trace) curr_ob;
       if (!curr_trace.nets_equal(p_net_no_arr)) {
         continue;
       }
       if (curr_trace.first_corner().equals(p_location)) {
         Collection<Item> contacts = curr_trace.get_start_contacts();
         if (contacts.size() == 0) {
           return curr_trace;
         }
       }
       if (curr_trace.last_corner().equals(p_location)) {
         Collection<Item> contacts = curr_trace.get_end_contacts();
         if (contacts.size() == 0) {
           return curr_trace;
         }
       }
     }
   }
   return null;
 }
Esempio n. 2
0
 /**
  * Checks, if p_item item is part of a cycle and remuve it together with its connection in this
  * case.
  */
 public boolean remove_if_cycle(Trace p_trace) {
   if (!p_trace.is_on_the_board()) {
     return false;
   }
   if (!p_trace.is_cycle()) {
     return false;
   }
   // Remove tails at the endpoints after removing the cycle,
   // if there was no tail before.
   boolean[] tail_at_endpoint_before = null;
   Point[] end_corners = null;
   int curr_layer = p_trace.get_layer();
   int[] curr_net_no_arr = p_trace.net_no_arr;
   end_corners = new Point[2];
   end_corners[0] = p_trace.first_corner();
   end_corners[1] = p_trace.last_corner();
   tail_at_endpoint_before = new boolean[2];
   for (int i = 0; i < 2; ++i) {
     Trace tail = get_trace_tail(end_corners[i], curr_layer, curr_net_no_arr);
     tail_at_endpoint_before[i] = (tail != null);
   }
   Set<Item> connection_items = p_trace.get_connection_items();
   this.remove_items(connection_items, false);
   for (int i = 0; i < 2; ++i) {
     if (!tail_at_endpoint_before[i]) {
       Trace tail = get_trace_tail(end_corners[i], curr_layer, curr_net_no_arr);
       if (tail != null) {
         remove_items(tail.get_connection_items(), false);
       }
     }
   }
   return true;
 }
Esempio n. 3
0
 Point normal_contact_point(Trace p_other) {
   if (this.layer != p_other.layer) {
     return null;
   }
   boolean contact_at_first_corner =
       this.first_corner().equals(p_other.first_corner())
           || this.first_corner().equals(p_other.last_corner());
   boolean contact_at_last_corner =
       this.last_corner().equals(p_other.first_corner())
           || this.last_corner().equals(p_other.last_corner());
   Point result;
   if (!(contact_at_first_corner || contact_at_last_corner)
       || contact_at_first_corner && contact_at_last_corner) {
     // no contact point or more than 1 contact point
     result = null;
   } else if (contact_at_first_corner) {
     result = this.first_corner();
   } else // contact at last corner
   {
     result = this.last_corner();
   }
   return result;
 }
Esempio n. 4
0
 /**
  * Maybe trace of type turret without net in Mentor design. Try to assig the net by calculating
  * the overlaps.
  */
 private void try_correct_net(Item p_item) {
   if (!(p_item instanceof Trace)) {
     return;
   }
   Trace curr_trace = (Trace) p_item;
   java.util.Set<Item> contacts = curr_trace.get_normal_contacts(curr_trace.first_corner(), true);
   contacts.addAll(curr_trace.get_normal_contacts(curr_trace.last_corner(), true));
   int corrected_net_no = 0;
   for (Item curr_contact : contacts) {
     if (curr_contact.net_count() == 1) {
       corrected_net_no = curr_contact.get_net_no(0);
       break;
     }
   }
   if (corrected_net_no != 0) {
     p_item.assign_net_no(corrected_net_no);
   }
 }
Esempio n. 5
0
 /**
  * Get a list of all items having a connection point at p_point on the layer of this trace. If
  * p_ignore_net is false, only contacts to items sharing a net with this trace are calculated.
  * This is the normal case.
  *
  * @param p_point a {@link geometry.planar.Point} object.
  * @param p_ignore_net a boolean.
  * @return a {@link java.util.Set} object.
  */
 public Set<Item> get_normal_contacts(Point p_point, boolean p_ignore_net) {
   if (p_point == null
       || !(p_point.equals(this.first_corner()) || p_point.equals(this.last_corner()))) {
     return new TreeSet<Item>();
   }
   TileShape search_shape = TileShape.get_instance(p_point);
   Set<SearchTreeObject> overlaps = board.overlapping_objects(search_shape, this.layer);
   Set<Item> result = new TreeSet<Item>();
   for (SearchTreeObject curr_ob : overlaps) {
     if (!(curr_ob instanceof Item)) {
       continue;
     }
     Item curr_item = (Item) curr_ob;
     if (curr_item != this
         && curr_item.shares_layer(this)
         && (p_ignore_net || curr_item.shares_net(this))) {
       if (curr_item instanceof Trace) {
         Trace curr_trace = (Trace) curr_item;
         if (p_point.equals(curr_trace.first_corner())
             || p_point.equals(curr_trace.last_corner())) {
           result.add(curr_item);
         }
       } else if (curr_item instanceof DrillItem) {
         DrillItem curr_drill_item = (DrillItem) curr_item;
         if (p_point.equals(curr_drill_item.get_center())) {
           result.add(curr_item);
         }
       } else if (curr_item instanceof ConductionArea) {
         ConductionArea curr_area = (ConductionArea) curr_item;
         if (curr_area.get_area().contains(p_point)) {
           result.add(curr_item);
         }
       }
     }
   }
   return result;
 }