import math.geom2d.conic.Circle2D; //导入依赖的package包/类
@Override
public CircleLine2D transform(CircleInversion2D inv) {
	// Extract inversion parameters
       Point2D center 	= inv.getCenter();
       double r 		= inv.getRadius();
       
       Point2D po 	= this.getProjectedPoint(center);
       double d 	= this.getDistance(po);

       // Degenerate case of a point belonging to the line:
       // the transform is the line itself.
       if (Math.abs(d)<Shape2D.ACCURACY){
       	return new StraightLine2D(this);
       }
       
       // angle from center to line
       double angle = Angle2D.getHorizontalAngle(center, po);

       // center of transformed circle
       double r2 	= r*r/d/2;
       Point2D c2 	= Point2D.createPolar(center, r2, angle);

       // choose direction of circle arc
       boolean direct = !this.isInside(center);
       
       // return the created circle
       return new Circle2D(c2, r2, direct);
   }
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
/**
 * Compute the intersections, if they exist, of two circulinear elements.
 */
public static Collection<Point2D> findIntersections(
		CirculinearElement2D elem1, 
		CirculinearElement2D elem2) {
	
	// First try to use linear shape methods
	if(elem1 instanceof LinearShape2D) {
		return elem2.getIntersections((LinearShape2D) elem1);
	}		
	if(elem2 instanceof LinearShape2D) {
		return elem1.getIntersections((LinearShape2D) elem2);
	}
	
	// From now, both elem1 and elem2 are instances of CircleShape2D
	// It is therefore possible to extract support circles
	Circle2D circ1 = ((CircularShape2D) elem1).getSupportingCircle();
	Circle2D circ2 = ((CircularShape2D) elem2).getSupportingCircle();
	
	// create array for storing result (max 2 possible intersections)
	ArrayList<Point2D> pts = new ArrayList<Point2D>(2);
	
	// for each of the circle intersections, check if they belong to
	// both elements
	for(Point2D inter : Circle2D.getIntersections(circ1, circ2)) {
		if(elem1.contains(inter) && elem2.contains(inter))
			pts.add(inter);
	}
	
	// return found intersections
	return pts;
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
/**
 * Compute buffer of a point set.
 */
public static CirculinearDomain2D computeBuffer(PointSet2D set, 
		double dist) {
	// create array for storing result
	Collection<CirculinearContour2D> contours = 
		new ArrayList<CirculinearContour2D>(set.getPointNumber());
	
	// for each point, add a new circle
	for(Point2D point : set) {
		contours.add(new Circle2D(point, Math.abs(dist), dist>0));
	}
	
	// process circles to remove intersections
	contours = splitIntersectingContours(contours);
	
	// Remove contours that cross or that are too close from base curve
	ArrayList<CirculinearContour2D> contours2 = 
		new ArrayList<CirculinearContour2D>(contours.size());
	for(CirculinearContour2D ring : contours) {
		
		// check that vertices of contour are not too close from original
		// curve
		double minDist = getDistanceCurvePoints(ring, set.getPoints());
		if(minDist<dist-Shape2D.ACCURACY)
			continue;
		
		// keep the contours that meet the above conditions
		contours2.add(ring);
	}

	return new GenericCirculinearDomain2D(new CirculinearBoundarySet2D(contours2));
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
protected void drawCircle(Graphics2D g, ScreenTransform t, Pair<Integer, Integer> location, int range) {
    int x = location.first();
    int y = location.second();
    int d = t.xToScreen(x + range) - t.xToScreen(x);
    Circle2D circle2D = new Circle2D(t.xToScreen(x), t.yToScreen(y), d, true);
    circle2D.draw(g);
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
@Override
public Collection<RenderedObject> render(Graphics2D g, ScreenTransform t, int width, int height) {
    if (xy != null) {
        int radius = 20;
        int x = t.xToScreen(xy.first());
        int y = t.yToScreen(xy.second());
        g.setColor(valueColor);
        g.drawOval(x - radius, y - radius, radius << 1, radius << 1);

        Circle2D circle2D = new Circle2D(t.xToScreen(xy.first()), t.yToScreen(xy.second()), 3d, true);
        circle2D.draw(g);
    }
    return new ArrayList<RenderedObject>();
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
@Override
    protected void paintData(Human h, Shape shape, Graphics2D g, ScreenTransform t) {
        g.setColor(Color.MAGENTA.darker());
        Circle2D circle2D = new Circle2D(t.xToScreen(h.getX()), t.yToScreen(h.getY()), 18d, true);
        circle2D.draw(g);
//        g.fill(shape);
    }
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
@Override
public CircleLine2D transform(CircleInversion2D inv) {
    // Extract inversion parameters
    Point2D center = inv.center();
    double r = inv.radius();

    // projection of inversion center on the line
    Point2D po = this.projectedPoint(center);
    double d = this.distance(center);

    // Degenerate case of a point belonging to the line:
    // the transform is the line itself.
    if (Math.abs(d) < Shape2D.ACCURACY) {
        return new StraightLine2D(this);
    }

    // angle from center to line
    double angle = Angle2D.horizontalAngle(center, po);

    // center of transformed circle
    double r2 = r * r / d / 2;
    Point2D c2 = Point2D.createPolar(center, r2, angle);

    // choose direction of circle arc
    boolean direct = this.isInside(center);

    // return the created circle
    return new Circle2D(c2, r2, direct);
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
public CirculinearContour2D createParallelContour(
        CirculinearContour2D contour, double dist) {

    // straight line is already a circulinear contour
    if (contour instanceof StraightLine2D) {
        return ((StraightLine2D) contour).parallel(dist);
    }
    // The circle is already a circulinear contour
    if (contour instanceof Circle2D) {
        return ((Circle2D) contour).parallel(dist);
    }

    // extract collection of parallel curves, that connect each other
    Collection<CirculinearContinuousCurve2D> parallelCurves = getParallelElements(
            contour, dist);

    // Create a new boundary with the set of parallel curves
    return new BoundaryPolyCirculinearCurve2D(parallelCurves,
            contour.isClosed());
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
/**
 * Compute buffer of a point set.
 */
public CirculinearDomain2D computeBuffer(PointSet2D set, double dist) {
    // create array for storing result
    Collection<CirculinearContour2D> contours = new ArrayList<CirculinearContour2D>(
            set.size());

    // for each point, add a new circle
    for (Point2D point : set) {
        contours.add(new Circle2D(point, Math.abs(dist), dist > 0));
    }

    // process circles to remove intersections
    contours = CirculinearCurves2D.splitIntersectingContours(contours);

    // Remove contours that cross or that are too close from base curve
    ArrayList<CirculinearContour2D> contours2 = new ArrayList<CirculinearContour2D>(
            contours.size());
    for (CirculinearContour2D ring : contours) {

        // check that vertices of contour are not too close from original
        // curve
        double minDist = CirculinearCurves2D.getDistanceCurvePoints(ring,
                set.points());
        if (minDist < dist - Shape2D.ACCURACY)
            continue;

        // keep the contours that meet the above conditions
        contours2.add(ring);
    }

    return new GenericCirculinearDomain2D(new CirculinearContourArray2D(
            contours2));
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
public CircleInversion2D(Circle2D circle) {
    this.circle = circle;
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
public void setCircle(double xc, double yc, double r) {
    this.circle = new Circle2D(xc, yc, r);
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
public CirculinearDomain2D getBuffer(double dist) {
	return new GenericCirculinearDomain2D(
			new Circle2D(this, Math.abs(dist), dist>0));
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
@Override
public Shape render(E area, Graphics2D g, ScreenTransform t) {
    java.util.List<Edge> edges = area.getEdges();
    if (edges.isEmpty()) {
        return null;
    }

    int count = edges.size();
    int[] xs = new int[count];
    int[] ys = new int[count];
    int i = 0;
    for (Edge e : edges) {
        xs[i] = t.xToScreen(e.getStartX());
        ys[i] = t.yToScreen(e.getStartY());
        ++i;
    }
    Polygon shape = new Polygon(xs, ys, count);

    paintShape(area, shape, g);

    if (drawOverAllData
            && (StaticViewProperties.selectedObject == null || !agentEntitiesMap.containsKey(StaticViewProperties.selectedObject.getID()))) {
        if (overallEntities.contains(area.getID().getValue())) {
            paintData(area, shape, g);
        }
    } else if (StaticViewProperties.selectedObject != null
            && agentEntitiesMap.containsKey(StaticViewProperties.selectedObject.getID())
            && agentEntitiesMap.get(StaticViewProperties.selectedObject.getID()).contains(area.getID().getValue())) {
        paintData(area, shape, g);
    }

    if (area.equals(StaticViewProperties.selectedObject)) {
        Circle2D circle2D = new Circle2D(t.xToScreen(area.getX()), t.yToScreen(area.getY()), 18d);
        circle2D.draw(g);
    }

    for (Edge edge : edges) {
        paintEdge(edge, g, t);
    }
    return shape;
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
protected void defaultCircle(Human h, Graphics2D g, ScreenTransform t) {
    Circle2D circle2D = new Circle2D(t.xToScreen(h.getX()), t.yToScreen(h.getY()), 18d, true);
    circle2D.draw(g);
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
@Override
    public Shape render(E area, Graphics2D g, ScreenTransform t) {
        java.util.List<Edge> edges = area.getEdges();
        if (edges.isEmpty()) {
            return null;
        }

        int count = edges.size();
        int[] xs = new int[count];
        int[] ys = new int[count];
        int i = 0;
        for (Edge e : edges) {
            xs[i] = t.xToScreen(e.getStartX());
            ys[i] = t.yToScreen(e.getStartY());
            ++i;
        }
        Polygon shape = new Polygon(xs, ys, count);

        paintShape(area, shape, g);

        if (drawOverAllData
                && (StaticViewProperties.selectedObject == null || !agentEntitiesMap.containsKey(StaticViewProperties.selectedObject.getID()))) {
            if (overallEntities.contains(new BuildingDto(area.getID().getValue()))) {
//                paintData(area, shape, g);
            }
        } else {
            if (StaticViewProperties.selectedObject != null) {
                Map<Integer, BuildingDto> maps = agentEntitiesMap.get(StaticViewProperties.selectedObject.getID());
                if (agentEntitiesMap.containsKey(StaticViewProperties.selectedObject.getID())
                        && maps.keySet().contains(area.getID().getValue())) {
                    BuildingDto buildingDto = maps.get(area.getID().getValue());
                    paintData(area, (K) buildingDto, shape, g);
                }
            }
        }

        if (area.equals(StaticViewProperties.selectedObject)) {
            Circle2D circle2D = new Circle2D(t.xToScreen(area.getX()), t.yToScreen(area.getY()), 18d);
            circle2D.draw(g);
        }

        for (Edge edge : edges) {
            paintEdge(edge, g, t);
        }
        return shape;
    }
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
public static CircleInversion2D create(Circle2D circle) {
	return new CircleInversion2D(circle);
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
public CircleInversion2D(Circle2D circle) {
    this.center = circle.center();
    this.radius = circle.radius();
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
/**
 * Computes the intersections, if they exist, of two circulinear elements.
 */
public static Collection<Point2D> findIntersections(
		CirculinearElement2D elem1, CirculinearElement2D elem2) {

	// find which shapes are linear
	boolean b1 = elem1 instanceof LinearShape2D;
	boolean b2 = elem2 instanceof LinearShape2D;
	
	// if both elements are linear, check parallism to avoid computing
	// intersection of parallel lines
	if (b1 && b2) {
		LinearShape2D line1 = (LinearShape2D) elem1;
		LinearShape2D line2 = (LinearShape2D) elem2;
		
		// test parallel elements
		Vector2D v1 = line1.direction(); 
		Vector2D v2 = line2.direction(); 
		if (Vector2D.isColinear(v1, v2))
			return new ArrayList<Point2D>(0);
		
		return line1.intersections(line2);
	}
	
	// First try to use linear shape methods
	if (elem1 instanceof LinearShape2D) {
		return elem2.intersections((LinearShape2D) elem1);
	}
	if (elem2 instanceof LinearShape2D) {
		return elem1.intersections((LinearShape2D) elem2);
	}

	// From now, both elem1 and elem2 are instances of CircleShape2D
	// It is therefore possible to extract support circles
	Circle2D circ1 = ((CircularShape2D) elem1).supportingCircle();
	Circle2D circ2 = ((CircularShape2D) elem2).supportingCircle();

	// create array for storing result (max 2 possible intersections)
	ArrayList<Point2D> pts = new ArrayList<Point2D>(2);

	// for each of the circle intersections, check if they belong to
	// both elements
	for (Point2D inter : Circle2D.circlesIntersections(circ1, circ2)) {
		if (elem1.contains(inter) && elem2.contains(inter))
			pts.add(inter);
	}

	// return found intersections
	return pts;
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
public CirculinearDomain2D buffer(double dist) {
    return new GenericCirculinearDomain2D(new Circle2D(this,
            Math.abs(dist), dist > 0));
}
 

import math.geom2d.conic.Circle2D; //导入依赖的package包/类
/**
 * Create a circular domain with the reference located in the lower left
 *
 * @param r
 * @return
 */
public static CirculinearCurve2D getCircleDomain(double r) {
    return new Circle2D(r, r, r);
}