Package lt.refactory.primsAlgo.graph

Examples of lt.refactory.primsAlgo.graph.WeightedEdge


        secondEdge = getEdge(0, 4, 3, 0);
        thirdEdge = getEdge(0, 0, 0, 4);
        break;
      }
     
      graph.addEdgeWithNodes(new WeightedEdge(firstEdge, SteinersAlgorithm.getEdgeLength(firstEdge)));
      graph.addEdgeWithNodes(new WeightedEdge(secondEdge, SteinersAlgorithm.getEdgeLength(secondEdge)));
      graph.addEdgeWithNodes(new WeightedEdge(thirdEdge, SteinersAlgorithm.getEdgeLength(thirdEdge)));
     
    } catch (AddEdgeException ex) {
      ex.printStackTrace();
    }
   
View Full Code Here


  public void testGetTriangleWithWeights() {
    Edge firstEdge = objectsProvider.getEdge(1, 1, 2, 3);
    Edge secondEdge = objectsProvider.getEdge(1, 1, 3, 1);
   
    Edge thirdEdge = objectsProvider.getEdge(2, 3, 3, 1);
    WeightedEdge addedEdge = new WeightedEdge(thirdEdge, SteinersAlgorithm.getEdgeLength(thirdEdge));
   
    Graph<WeightedEdge> triangle;
    try {
      triangle = SteinersAlgorithm.getTriangleWithWeights(firstEdge, secondEdge);
     
View Full Code Here

    try {
      Graph<WeightedEdge> firstEquilateralTriangle = SteinersAlgorithm.getEquilateralTriangle(firstTriangle);
      Graph<WeightedEdge> secondEquilateralTriangle = SteinersAlgorithm.getEquilateralTriangle(secondTriangle);
      Graph<WeightedEdge> thirdEquilateralTriangle = SteinersAlgorithm.getEquilateralTriangle(thirdTriangle);
     
      WeightedEdge firstEdge = SteinersAlgorithm.getEdgeThroughTriangles(firstTriangle, firstEquilateralTriangle);
      WeightedEdge secondEdge = SteinersAlgorithm.getEdgeThroughTriangles(secondTriangle, secondEquilateralTriangle);
      WeightedEdge thirdEdge = SteinersAlgorithm.getEdgeThroughTriangles(thirdTriangle, thirdEquilateralTriangle);
     
      // check if edges through triangles consists nodes from triangles
      assertTrue(firstTriangle.containsNode(firstEdge.getStart()) || firstEquilateralTriangle.containsNode(firstEdge.getStart()));
      assertTrue(firstTriangle.containsNode(firstEdge.getEnd()) || firstEquilateralTriangle.containsNode(firstEdge.getEnd()));
     
      assertTrue(secondTriangle.containsNode(secondEdge.getStart()) || secondEquilateralTriangle.containsNode(secondEdge.getStart()));
      assertTrue(secondTriangle.containsNode(secondEdge.getEnd()) || secondEquilateralTriangle.containsNode(secondEdge.getEnd()));
     
      assertTrue(thirdTriangle.containsNode(thirdEdge.getStart()) || thirdEquilateralTriangle.containsNode(thirdEdge.getStart()));
      assertTrue(thirdTriangle.containsNode(thirdEdge.getEnd()) || thirdEquilateralTriangle.containsNode(thirdEdge.getEnd()));     
    } catch (AddEdgeException e) {
      fail("Add edge exception thrown");
    } catch (AlgorithmException e) {
      fail("Algorithm exception thrown");
    }
View Full Code Here

     
      Circle firstCircle = SteinersAlgorithm.getCircumscribedCircle(firstEquilateralTriangle);
      Circle secondCircle = SteinersAlgorithm.getCircumscribedCircle(secondEquilateralTriangle);
      Circle thirdCircle = SteinersAlgorithm.getCircumscribedCircle(thirdEquilateralTriangle);
     
      WeightedEdge firstEdge = SteinersAlgorithm.getEdgeThroughTriangles(firstTriangle, firstEquilateralTriangle);
      WeightedEdge secondEdge = SteinersAlgorithm.getEdgeThroughTriangles(secondTriangle, secondEquilateralTriangle);
      WeightedEdge thirdEdge = SteinersAlgorithm.getEdgeThroughTriangles(thirdTriangle, thirdEquilateralTriangle);
     
      Node firstPoint = SteinersAlgorithm.getSteinersPoint(firstEdge, firstCircle);
      Node secondPoint = SteinersAlgorithm.getSteinersPoint(secondEdge, secondCircle);
      Node thirdPoint = SteinersAlgorithm.getSteinersPoint(thirdEdge, thirdCircle);
     
View Full Code Here

 
  @Test
  public void testChangeGraphEdges() {
    try {
      Graph<WeightedEdge> firstTriangle = objectsProvider.getTriangle(1);    // first line vertical
      WeightedEdge edge = firstTriangle.getEdgeList().get(0);
      WeightedEdge nearEdge = firstTriangle.getEdgeList().get(1);
     
      Graph<WeightedEdge> firstEquilateralTriangle = SteinersAlgorithm.getEquilateralTriangle(firstTriangle);
     
      Circle firstCircle = SteinersAlgorithm.getCircumscribedCircle(firstEquilateralTriangle);
     
      WeightedEdge firstEdge = SteinersAlgorithm.getEdgeThroughTriangles(firstTriangle, firstEquilateralTriangle);
     
      Node firstPoint = SteinersAlgorithm.getSteinersPoint(firstEdge, firstCircle);
     
      Graph<WeightedEdge> changedGraph = SteinersAlgorithm.changeGraphEdges(firstTriangle, edge, nearEdge, firstPoint);
     
View Full Code Here

        secondNode = secondEdge.getEnd();
      }
      Edge thirdEdge = new Edge(firstNode, secondNode);
     
      Graph<WeightedEdge> triangle = new Graph<WeightedEdge>();
      triangle.addEdgeWithNodes(new WeightedEdge(firstEdge, SteinersAlgorithm.getEdgeLength(firstEdge)));
      triangle.addEdgeWithNodes(new WeightedEdge(secondEdge, SteinersAlgorithm.getEdgeLength(secondEdge)));
      triangle.addEdgeWithNodes(new WeightedEdge(thirdEdge, SteinersAlgorithm.getEdgeLength(thirdEdge)));
     
      return triangle;
    }
    throw new AlgorithmException("Edges must have a common point to form a triangle");
  }
View Full Code Here

  }
 
  public static Graph<WeightedEdge> getEquilateralTriangle(Graph<WeightedEdge> triangle) throws AddEdgeException {
   
    // any edge is suitable for equilateral triangle construction - let's take first
    WeightedEdge edge = triangle.getEdgeList().get(0);
   
    LinearFunctionParameters linearParameters = SteinersAlgorithm.getLinearFunctionParameters(edge.getStart(), edge.getEnd());

    // find node which does not belong to edge - another node will have one
    Node oppositeSideNode;
    if (edge.containsNode(triangle.getEdgeList().get(1).getStart())) {
      oppositeSideNode = triangle.getEdgeList().get(1).getEnd();
    } else {
      oppositeSideNode = triangle.getEdgeList().get(1).getStart();
    }
   
    int oppositeSide;
    // special case when we got a vertical line
    if (linearParameters.getDx().compareTo(BigDecimal.ZERO) == 0) {
      oppositeSide = oppositeSideNode.getPointX().compareTo(edge.getStart().getPointX());
    } else {
      // is (k * x + b - y) > 0
      oppositeSide = linearParameters.getK()
          .multiply(oppositeSideNode.getPointX())
          .add(linearParameters.getB())
          .subtract(oppositeSideNode.getPointY())
          .compareTo(BigDecimal.ZERO);
    }
   
    BigDecimal Cos60 = BigDecimal.valueOf(Math.cos(Math.toRadians(60))).round(new MathContext(ROUNDING_PRECISION, ROUNDING_MODE));
    BigDecimal Sin60 = BigDecimal.valueOf(Math.sin(Math.toRadians(60))).round(new MathContext(ROUNDING_PRECISION, ROUNDING_MODE));
   
    // try to turn point clockwise to find coordinates of the third triangle's point
    BigDecimal turnedX = Cos60.multiply(linearParameters.getDx()).subtract(Sin60.multiply(linearParameters.getDy())).add(edge.getStart().getPointX());
    BigDecimal turnedY = Sin60.multiply(linearParameters.getDx()).add(Cos60.multiply(linearParameters.getDy())).add(edge.getStart().getPointY());
   
    // check if points are in different sides
    // special case when line is vertical
    int thirdNodeSide;
    if (linearParameters.getDx().compareTo(BigDecimal.ZERO) == 0) {
      thirdNodeSide = turnedX.compareTo(edge.getStart().getPointX());
    } else {
      thirdNodeSide = linearParameters.getK()
          .multiply(turnedX)
          .add(linearParameters.getB())
          .subtract(turnedY)
          .compareTo(BigDecimal.ZERO);
    }
   
    // if points are in the same side, need to turn to opposite side
    if (oppositeSide == thirdNodeSide) {
      turnedX = Cos60.multiply(linearParameters.getDx()).add(Sin60.multiply(linearParameters.getDy())).add(edge.getStart().getPointX());
      turnedY = Sin60.negate().multiply(linearParameters.getDx()).add(Cos60.multiply(linearParameters.getDy())).add(edge.getStart().getPointY());
    }
   
    Node newNode = new Node(turnedX, turnedY);
   
    Graph<WeightedEdge> equilateralTriangle = new Graph<WeightedEdge>();
    equilateralTriangle.addEdgeWithNodes(edge);
    equilateralTriangle.addEdgeWithNodes(new WeightedEdge(new Edge(edge.getStart(), newNode), edge.getWeight()));
    equilateralTriangle.addEdgeWithNodes(new WeightedEdge(new Edge(edge.getEnd(), newNode), edge.getWeight()));
   
    return equilateralTriangle;
  }
View Full Code Here

    Graph<WeightedEdge> smallestTreeWithSteinersPoint = new Graph<WeightedEdge>(smallestTreeFull);
    BigDecimal biggestDifference = BigDecimal.ZERO;
    try {
     
      while (smallestTree.getEdgeListSize() > 1) {
        WeightedEdge leave = SteinersAlgorithm.getGraphLeave(smallestTree);
       
        // if no more leaves are in graph return result
        if (leave == null) {
          return smallestTreeWithSteinersPoint;
        }
       
        WeightedEdge nearEdge = smallestTree.getNearEdges(leave).get(0)// leave always have one near edge
        BigDecimal angleBetweenEdges = SteinersAlgorithm.getAngleBetweenTwoEdges(leave, nearEdge);
       
        if (angleBetweenEdges.compareTo(BigDecimal.valueOf(120)) == -1) {
          // Torichelli procedure for steiners point:
          Graph<WeightedEdge> triangle = SteinersAlgorithm.getTriangleWithWeights(leave, nearEdge);
          Graph<WeightedEdge> equilateralTriangle = SteinersAlgorithm.getEquilateralTriangle(triangle);
          Circle circumscribedCircle = SteinersAlgorithm.getCircumscribedCircle(equilateralTriangle);
          WeightedEdge edgeThroughTriangles = SteinersAlgorithm.getEdgeThroughTriangles(triangle, equilateralTriangle);
          Node steinersPoint = SteinersAlgorithm.getSteinersPoint(edgeThroughTriangles, circumscribedCircle);
         
          if (steinersPoint != null) {
            // Calculate how much graph is shorter than initial graph
            Graph<WeightedEdge> changedGraph = SteinersAlgorithm.changeGraphEdges(smallestTreeFull, leave, nearEdge, steinersPoint);
View Full Code Here

    // circle radius equation r = sqrt(3) / 3 * a
    BigDecimal radius = BigDecimal.valueOf((Math.sqrt(3) / 3) * triangle.getEdgeList().get(0).getWeight().doubleValue());
   
    // we need two edges for center point finding
    WeightedEdge firstEdge = triangle.getEdgeList().get(0);
    WeightedEdge secondEdge = triangle.getEdgeList().get(1);
   
    // find middle-edge edges
    WeightedEdge firstMiddleEdge = getMiddleEdge(firstEdge, secondEdge);
    WeightedEdge secondMiddleEdge = getMiddleEdge(secondEdge, firstEdge);
   
    LinearFunctionParameters firstEdgeParameters = getLinearFunctionParameters(firstMiddleEdge.getStart(), firstMiddleEdge.getEnd());
    LinearFunctionParameters secondEdgeParameters = getLinearFunctionParameters(secondMiddleEdge.getStart(), secondMiddleEdge.getEnd());
   
    BigDecimal centerX = null;
    BigDecimal centerY = null;
   
    // special case when one of the edges is vertical
    if (firstEdgeParameters.getDx().compareTo(BigDecimal.ZERO) == 0) {
     
      centerX = firstMiddleEdge.getStart().getPointX();
      centerY = secondEdgeParameters.getK()
          .multiply(centerX)
          .add(secondEdgeParameters.getB());
     
    } else if (secondEdgeParameters.getDx().compareTo(BigDecimal.ZERO) == 0 ) {
     
      centerX = secondMiddleEdge.getStart().getPointX();
      centerY = firstEdgeParameters.getK()
          .multiply(centerX)
          .add(firstEdgeParameters.getB());
    } else {
      // x = (b2 - b1) / ( k1 - k2 )
View Full Code Here

    BigDecimal midX = mainEdge.getEnd().getPointX().add(mainEdge.getStart().getPointX()).divide(BigDecimal.valueOf(2));
    BigDecimal midY = mainEdge.getEnd().getPointY().add(mainEdge.getStart().getPointY()).divide(BigDecimal.valueOf(2));
    Node anotherPoint = mainEdge.containsNode(nearEdge.getStart()) ? nearEdge.getEnd() : nearEdge.getStart();
    Edge midEdge = new Edge(new Node(midX, midY), anotherPoint);
   
    return new WeightedEdge(midEdge, getEdgeLength(midEdge));
  }
View Full Code Here

TOP

Related Classes of lt.refactory.primsAlgo.graph.WeightedEdge

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.