208 lines
5.7 KiB
Java
208 lines
5.7 KiB
Java
/*
|
|
* Copyright (C) 2014 Alfons Wirtz
|
|
* website www.freerouting.net
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License at <http://www.gnu.org/licenses/>
|
|
* for more details.
|
|
*
|
|
* ObstacleExpansionRoom.java
|
|
*
|
|
* Created on 17. April 2006, 06:45
|
|
*
|
|
*/
|
|
|
|
package eu.mihosoft.freerouting.autoroute;
|
|
|
|
import java.util.List;
|
|
import java.util.Collection;
|
|
|
|
import eu.mihosoft.freerouting.board.ShapeSearchTree;
|
|
import eu.mihosoft.freerouting.board.SearchTreeObject;
|
|
import eu.mihosoft.freerouting.board.PolylineTrace;
|
|
|
|
import eu.mihosoft.freerouting.geometry.planar.TileShape;
|
|
|
|
import eu.mihosoft.freerouting.board.Item;
|
|
|
|
/**
|
|
* Expansion Room used for pushing and ripping obstacles in the eu.mihosoft.freerouting.autoroute algorithm.
|
|
*
|
|
* @author Alfons Wirtz
|
|
*/
|
|
public class ObstacleExpansionRoom implements CompleteExpansionRoom
|
|
{
|
|
|
|
/** Creates a new instance of ObstacleExpansionRoom */
|
|
ObstacleExpansionRoom(Item p_item, int p_index_in_item, ShapeSearchTree p_shape_tree)
|
|
{
|
|
this.item = p_item;
|
|
this.index_in_item = p_index_in_item;
|
|
this.shape = p_item.get_tree_shape(p_shape_tree, p_index_in_item);
|
|
this.doors = new java.util.LinkedList<ExpansionDoor>();
|
|
}
|
|
|
|
public int get_index_in_item()
|
|
{
|
|
return this.index_in_item;
|
|
}
|
|
|
|
public int get_layer()
|
|
{
|
|
return this.item.shape_layer(this.index_in_item);
|
|
}
|
|
|
|
public TileShape get_shape()
|
|
{
|
|
return this.shape;
|
|
}
|
|
|
|
/**
|
|
* Checks, if this room has already a 1-dimensional door to p_other
|
|
*/
|
|
public boolean door_exists(ExpansionRoom p_other)
|
|
{
|
|
if (doors != null)
|
|
{
|
|
for (ExpansionDoor curr_door : this.doors)
|
|
{
|
|
if (curr_door.first_room == p_other || curr_door.second_room == p_other)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Adds a door to the door list of this room.
|
|
*/
|
|
public void add_door(ExpansionDoor p_door)
|
|
{
|
|
this.doors.add(p_door);
|
|
}
|
|
|
|
/**
|
|
* Creates a 2-dim door with the other obstacle room, if that is useful for the eu.mihosoft.freerouting.autoroute algorithm.
|
|
* It is assumed that this room and p_other have a 2-dimensional overlap.
|
|
* Returns false, if no door was created.
|
|
*/
|
|
public boolean create_overlap_door(ObstacleExpansionRoom p_other)
|
|
{
|
|
if (this.door_exists(p_other))
|
|
{
|
|
return false;
|
|
}
|
|
if (!(this.item.is_route() && p_other.item.is_route()))
|
|
{
|
|
return false;
|
|
}
|
|
if (!this.item.shares_net(p_other.item))
|
|
{
|
|
return false;
|
|
}
|
|
if (this.item == p_other.item)
|
|
{
|
|
if (!(this.item instanceof PolylineTrace))
|
|
{
|
|
return false;
|
|
}
|
|
// create only doors between consecutive trace segments
|
|
if (this.index_in_item != p_other.index_in_item + 1 && this.index_in_item != p_other.index_in_item - 1)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
ExpansionDoor new_door = new ExpansionDoor(this, p_other, 2);
|
|
this.add_door(new_door);
|
|
p_other.add_door(new_door);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Returns the list of doors of this room to neighbour expansion rooms
|
|
*/
|
|
public List<ExpansionDoor> get_doors()
|
|
{
|
|
return this.doors;
|
|
}
|
|
|
|
/**
|
|
* Removes all doors from this room.
|
|
*/
|
|
public void clear_doors()
|
|
{
|
|
this.doors = new java.util.LinkedList<ExpansionDoor>();
|
|
}
|
|
|
|
public void reset_doors()
|
|
{
|
|
for (ExpandableObject curr_door : this.doors)
|
|
{
|
|
curr_door.reset();
|
|
}
|
|
}
|
|
|
|
public Collection<TargetItemExpansionDoor> get_target_doors()
|
|
{
|
|
return new java.util.LinkedList<TargetItemExpansionDoor>();
|
|
}
|
|
|
|
public Item get_item()
|
|
{
|
|
return this.item;
|
|
}
|
|
|
|
public SearchTreeObject get_object()
|
|
{
|
|
return this.item;
|
|
}
|
|
|
|
public boolean remove_door(ExpandableObject p_door)
|
|
{
|
|
return this.doors.remove(p_door);
|
|
}
|
|
|
|
/**
|
|
* Returns, if all doors to the neighbour rooms are calculated.
|
|
*/
|
|
boolean all_doors_calculated()
|
|
{
|
|
return this.doors_calculated;
|
|
}
|
|
|
|
void set_doors_calculated(boolean p_value)
|
|
{
|
|
this.doors_calculated = p_value;
|
|
}
|
|
|
|
|
|
/**
|
|
* Draws the shape of this room.
|
|
*/
|
|
public void draw(java.awt.Graphics p_graphics, eu.mihosoft.freerouting.boardgraphics.GraphicsContext p_graphics_context, double p_intensity)
|
|
{
|
|
java.awt.Color draw_color = java.awt.Color.WHITE;
|
|
double layer_visibility = p_graphics_context.get_layer_visibility(this.get_layer());
|
|
p_graphics_context.fill_area(this.get_shape(), p_graphics, draw_color, p_intensity * layer_visibility);
|
|
p_graphics_context.draw_boundary(this.get_shape(), 0, draw_color, p_graphics, layer_visibility);
|
|
}
|
|
|
|
private final Item item;
|
|
private final int index_in_item;
|
|
private final TileShape shape;
|
|
|
|
/** The list of doors to neighbour expansion rooms */
|
|
private List<ExpansionDoor> doors;
|
|
|
|
private boolean doors_calculated = false;
|
|
}
|