Package org.codemap.util.geom

Examples of org.codemap.util.geom.Point2D$Float


        // 1. set the grandParent catmull-rom point. This is the parent of n1
        n2 = n1.getRoutingParent();
        if (n2 == null) {
            //System.out.println("n2 is null");
            Point2D n1Pt = n1.getLocation();
            // if the grandParent doesn't exist (this is the root),
            // then we want to construct a grandParent point that is suitable.
            // we do this by taking the average position of all the children
            // constructing the vector between the node and those children
            // flipping the vector, and moving it away from the parent point
            Iterator gpIter = n1.getOutEdges().iterator();
           
            //System.out.println("n1.outEdges: " + n1.getOutEdges().size());
            double avgX, avgY;
            int count = 0;
            avgX = avgY = 0;
            while (gpIter.hasNext()) {
                Edge e2 = (Edge) gpIter.next();
                Point2D e2Pt = e2.getSecondNode()
                        .getLocation();
                //System.out.println("averaging points: " + e2Pt);
                avgX += e2Pt.getX();
                avgY += e2Pt.getY();
                count++;
            }

            avgX /= count;
            avgY /= count;
            Vector2D gpVec = new Vector2D(n1Pt, new Point2D.Double(avgX, avgY));
            Point2D gpVecNorm = gpVec.getNormalized();
            gpVecNorm.setLocation(-1 * gpVecNorm.getX(), -1 * gpVecNorm.getY());
            grandParent = new Point2D.Double(n1Pt.getX() + 10
                    * gpVecNorm.getX(), n1Pt.getY() + 10 * gpVecNorm.getY());
           

        } else {
            //System.out.println("n2 is not null");
            grandParent = n1.getPrevControlPoint();
            //System.out.println("Prev Control Point for " +
            // ((FlowNode)n1.getEntity()).toStringId() + " has prev control
            // point: " + grandParent);
        }
        //System.out.println("grandparent: " + grandParent);

        // 2. the parent catmull-rom point is n1, since we want it to
        // go through this point
        parent = n1.getLocation();
       
        Point2D shiftPoint = null;
        // additive edge code
        // only shift edges if we are not at the root
        // relies on the fact that there only 2 edges per node
        if (m_additiveEdges && (n1.getRoutingParent() != null)) {

            n2 = n1.getRoutingParent(); //redundant, but who cares
           
            // get the other edge that starts from n1
            Edge otherEdgeItem = null;
            //System.out.println("n1.getOutEdges().size() " + n1.getOutEdges().size());
            for (Edge other: n1.getOutEdges()) {
                if ((otherEdgeItem = other) != edge) break;
            }
            assert(otherEdgeItem != null);
           
//          find the parent edge from n2 to n1
            Edge parentEdgeItem = null;
            for (Edge parent: n2.getOutEdges()) {
                parentEdgeItem = parent;
                if (parentEdgeItem.isIncident(n1) && (parentEdgeItem.isIncident(n2))) {
                    break;               
                }
            }
            assert(parentEdgeItem != null);
           
            Node item1;
            Node item2;
            // get vectors for both edges
            item1 = edge.getFirstNode();
            item2 = edge.getSecondNode();
            Vector2D thisEdgeVec = new Vector2D(item1.getLocation(), item2.getLocation());
           
            item1 = otherEdgeItem.getFirstNode();
            item2 = otherEdgeItem.getSecondNode();
            Vector2D otherEdgeVec = new Vector2D(item1.getLocation(), item2.getLocation());
           
            // now do the cross product of thisEdgeVec
           
//            do not use Vector3d but own implementation that gets rid of this dependency
//            Vector3d thisEdgeVector = new Vector3d(thisEdgeVec.getNormalized().getX(), -1*thisEdgeVec.getNormalized().getY(), 0);
//            Vector3d otherEdgeVector = new Vector3d(otherEdgeVec.getNormalized().getX(), -1*otherEdgeVec.getNormalized().getY(), 0);
//           
//            Vector3d result = new Vector3d();
//
//            result.cross(thisEdgeVector, otherEdgeVector);
            double[] cross = computeCrossProduct(thisEdgeVec.getNormalized().getX(), -1*thisEdgeVec.getNormalized().getY(),
                    otherEdgeVec.getNormalized().getX(), -1*otherEdgeVec.getNormalized().getY());
            //System.out.println("edges: " + parentEdgeItem + ", " + edgeItem + " , " + otherEdgeItem);
            //System.out.println(result);
           
            // compute the perpendicular vector, the direction to shift
            // we will get a vector that points to the right
            Vector2D grandToParent = new Vector2D(grandParent, parent);
            Point2D shiftDir = new Point2D.Double(-grandToParent.getNormalized().getY(),
                    -grandToParent.getNormalized().getX());
           
//            if (result.z < 0) {
            if (cross[2] < 0 ) {
            // if z > 0 then we know that thisEdge is to the right of otherEdge
            // so we push this in the direction of shiftDir

            // else we know that thisEdge is to the left of otherEdge
            // so we push this up, or in the negative direction of shiftDir
                shiftDir.setLocation(shiftDir.getX()*-1, shiftDir.getY()*-1);
            }
           
            double parentWidth = scale.getDisplayWidth(parentEdgeItem.getWeight());
            double otherWidth = scale.getDisplayWidth(otherEdgeItem.getWeight());
            parentWidth = Math.round(parentWidth);
            otherWidth = Math.round(otherWidth);
    /*
            System.out.println("edges: par: " + parentEdgeItem + ", edge:" + edgeItem + " , other:" + otherEdgeItem);
            System.out.println("parentActual: " + parentEdgeItem.getWeight(currFlowType) + " dispActual: " + edgeItem.getWeight(currFlowType) + " otherActual: " + otherEdgeItem.getWeight(currFlowType));
            System.out.println("parentWidth: " + parentWidth + " dispWidth: " + displayWidth + " otherWidth: " + otherWidth);
        */ 
            assert(parentWidth >= displayWidth);
           
            // compute the distance to shift this edge. It should be:
            // parentDisplayWidth/2 - displayWidth/2
            double shiftDist = (parentWidth/2) - (displayWidth/2);
           
            shiftPoint = new Point2D.Double(shiftDist*shiftDir.getX(),
                    -1*shiftDist*shiftDir.getY());

        }

        // 6. Set the child catmull-rom pont to be e1.to
        child = edge.getSecondNode().getLocation();

        // 7. Compute the grand child catmull-rom point.
        // It is either the position of the heavier child,
        // or if there are no more child nodes, it is in a straight
        // line with parent and child, just further out
        Collection<Edge> grandChildEdges = edge.getSecondNode().getOutEdges();
        if (grandChildEdges.size() != 0) {
            double gcWeight, gcX, gcY;
            gcX = gcY = gcWeight = -1;
           
            // find the heaviest child
            for(Edge gcEdge: grandChildEdges) {
                if (gcEdge.getWeight() > gcWeight) {
                    gcWeight = gcEdge.getWeight();
                    gcX = gcEdge.getSecondNode().getLocation().getX();
                    gcY = gcEdge.getSecondNode().getLocation().getY();
                    //System.out.println("x: " + gcX + " y:" + gcY);
                }                  
            }
            assert(gcWeight != -1);
            grandChild = new Point2D.Double(gcX, gcY);
            GraphicsGems.checkNaN(grandChild);
        } else {
            /*
            System.out.println();
            System.out.println(grandParent);
            System.out.println(parent);
            System.out.println(child);
            */
            Vector2D parentToChild = new Vector2D(parent, child);
            Point2D pToCDir = parentToChild.getNormalized();
           
        //  System.out.println(pToCDir);

            Vector2D grandParentToParent = new Vector2D(grandParent, parent);
            Point2D gpToPDir = grandParentToParent.getNormalized();
            //System.out.println(gpToPDir);

            double angleBetween = parentToChild
                    .absAngleBetween(grandParentToParent);
           
            //System.out.println(edgeItem + " angleBetween is " + (180*angleBetween/Math.PI));

            // now rotate the parentToChild normalized vector by -angleBetween
            // assuming rotations are CCW

            double x = pToCDir.getX() * Math.cos(-angleBetween)
                    - pToCDir.getY() * Math.sin(-angleBetween);
            double y = pToCDir.getX() * Math.sin(-angleBetween)
                    + pToCDir.getY() * Math.cos(-angleBetween);

            //System.out.println("grandChild case 2: " + x + "," + y);
            grandChild = new Point2D.Double(child.getX() + 100 * x, child
                    .getY()
                    + 100 * y);
            GraphicsGems.checkNaN(grandChild);

        }

       

        // 8. Now that we know where all the catmull-rom objects are,
        // construct a BasicStroke object with e1's thickness
//      haha, it's not even read ...
//        BasicStroke bs = new BasicStroke((float) displayWidth,
//                BasicStroke.CAP_SQUARE, BasicStroke.JOIN_ROUND);

        // 9. construct a CubicCurve object with the given control points
        // by passing the four points object to the BezierSpline.computeSplines
        // function
        fourPoints[0] = grandParent;
        fourPoints[1] = parent;
        fourPoints[2] = child;
        fourPoints[3] = grandChild;

        Shape shape = edge.getShape();
        CubicCurve2D myCurve;
        if (shape == null) {
            myCurve = new CubicCurve2D.Double();
            edge.setShape(myCurve);
        } else {
            myCurve = (CubicCurve2D)shape;
        }
       
        BezierSpline.computeOneSpline(grandParent, parent, child, grandChild, myCurve);

        // 11. Now do some tweaking of the control points to ensure continuity.
        // need to tweak the first control point to be collinear with the parent
        // and the grandparent and have the same distance as the
        // parent-grandparent
        double parentGrandDist = grandParent.distance(parent);

        Vector2D grandToParent = new Vector2D(grandParent, parent);
        //System.out.println(grandToParent);
        //now take the grandToParent vector, scale by parentGrandDistance, add
        // it to the parent vector
       
          Point2D collinShift = new Point2D.Double(parentGrandDist
                * grandToParent.getNormalized().getX() + parent.getX(),
                parentGrandDist * grandToParent.getNormalized().getY()
                        + parent.getY());
        //System.out.println("before: " + myCurve.getP1() + ", "
        // +myCurve.getCtrlP1() + ", " + myCurve.getCtrlP2() + ", " +
        // myCurve.getP2() );
        myCurve.setCurve(myCurve.getP1(), collinShift, myCurve.getCtrlP2(),
                myCurve.getP2());
        GraphicsGems.checkNaN(myCurve.getP1());
        GraphicsGems.checkNaN(myCurve.getP2());
        GraphicsGems.checkNaN(myCurve.getCtrlP1());
        GraphicsGems.checkNaN(myCurve.getCtrlP2());
       
        //System.out.println("after: " + myCurve.getP1() + ", "
        // +myCurve.getCtrlP1() + ", " + myCurve.getCtrlP2() + ", " +
        // myCurve.getP2() );

        //System.out.println("CollinShift dist: " +
        // collinShift.distance(parent) + " and p-GP dist: " + parentGrandDist);

        // 10. Need to set the previous control point for the child node
        Node otherItem = edge.getSecondNode();
        otherItem.setPrevControlPoint(myCurve.getCtrlP2());

        //System.out.println("Prev Control Point for " +
        // ((FlowNode)otherItem.getEntity()).toStringId() + " was set to prev
        // control point: " + grandParent);
       
        if ((m_additiveEdges) && (shiftPoint != null)) {
           
       
            // 12. Now shift the bezier points to line up properly with the horizontal translation
            // that takes into account the thickness of the curve. We do this by shifting
            // the first two points of every bezier to get it to line up in the appropriate place
            Point2D grandParentShift = new Point2D.Double(myCurve.getP1().getX()+shiftPoint.getX(),
                myCurve.getP1().getY()+shiftPoint.getY());
            Point2D parentShift = new Point2D.Double(myCurve.getCtrlP1().getX()+shiftPoint.getX(),
                myCurve.getCtrlP1().getY()+shiftPoint.getY());
            myCurve.setCurve(grandParentShift, parentShift, myCurve.getCtrlP2(), myCurve.getP2());
        }
        GraphicsGems.checkNaN(myCurve.getP1());
        GraphicsGems.checkNaN(myCurve.getP2());
View Full Code Here


  public Point2D getNormalized() {
    return normalized;
  }
 
  public double dotProduct(Vector2D other) {
    Point2D otherNorm = other.getNormalized();
    return normalized.getX()*otherNorm.getX() + normalized.getY()*otherNorm.getY();
  }
 
View Full Code Here

    // remember that for a vector (a,b)
    // and that the perpendicular vector is (-b,a)
    // now just dot perpendicular vector with the other vector,
    // if it is positive, do nothing,
    // if it is negative, add Math.PI
    Point2D otherNorm = other.getNormalized();
    double dot = -normalized.getY()*otherNorm.getX() + normalized.getX()*otherNorm.getY();
   
    if (dot >= 0)
      return angleBetw;
    else
      return 2*Math.PI - angleBetw;
View Full Code Here

   * @param parent the parent node of this cluster
   * @param clus the cluster we are drawing to (has 2 nodes)
   */
  private void processLeafCluster(Node parent, Cluster clus) {
    //System.out.println("LeafCluster Process: " + parent);
    Point2D parentPt = parent.getLocation();
    Point2D onePt = clus.oneCluster.getRenderedNode().getLocation();
    Point2D twoPt = clus.twoCluster.getRenderedNode().getLocation();
   
    GraphicsGems.checkNaN(onePt);
    GraphicsGems.checkNaN(twoPt);
   
    // figure out which leaf node is closer
    double oneDist, twoDist, closerDist;
    oneDist = parentPt.distance(onePt);
    twoDist = parentPt.distance(twoPt);
   
    if (oneDist < twoDist) {
      closerDist = oneDist;
    } else {
      closerDist = twoDist;
    }
   
    closerDist /= 2;
   
    // figure out which sub-cluster is bigger
    Point2D biggerPt;
    Cluster biggerClus, smallerClus;
    // find the distance between the parent and the node with more weight
    if (clus.oneCluster.getWeight() > clus.twoCluster.getWeight()) {
      biggerPt = onePt;
      biggerClus = clus.oneCluster;
      smallerClus = clus.twoCluster;
    } else {
      biggerPt = twoPt;
      biggerClus = clus.twoCluster;
      smallerClus = clus.oneCluster;
    }
   
    double biggerDist = parentPt.distance(biggerPt);
   
    // if closerDist is small, bigFraction is 0, so we want
    // the parentFraction to be big.
    double bigFraction = closerDist/biggerDist;
    double parentFraction = 1 - bigFraction;
   
    // set the newPt location to be newFraction of the way
    // between parentPt and biggerPt
    double x = parentPt.getX()*parentFraction+biggerPt.getX()*bigFraction;
    double y = parentPt.getY()*parentFraction+biggerPt.getY()*bigFraction;
   
        // create the new, intermediate node
        Node newNode = new Node(x, y);
        newNode.setChildCluster(clus);
        clus.setRenderedNode(newNode);   
View Full Code Here

   */
  private Node processMixedCluster(Node parent, Cluster parentCluster,
                       Cluster leafCluster, Cluster clus) {
    //System.out.println("MixedCluster Process: " + parent);
   
    Point2D parentPt = parent.getLocation();
    GraphicsGems.checkNaN(parentPt);
    //System.out.println("MixedCluster leafCluster " + leafCluster);
    Point2D onePt = leafCluster.getRenderedNode().getLocation();
    GraphicsGems.checkNaN(onePt);

    //twoPoint is a point between the parentPoint and the centerPoint
    Line2D parent2Center = new Line2D.Double(parentPt, clus.center);
    //System.out.println("MixedCluster parent2Center " + parentPt + " to " + clus.center);
    //System.out.println("MixedCluster: clus: " + clus + " " + clus.bounds);
    Point2D twoPt = GraphicsGems.closestIntersectBox(clus.bounds, parent2Center, parentPt);
    GraphicsGems.checkNaN(twoPt);
   
    //System.out.println("onePt " + onePt + " twoPt: " + twoPt);
   
    // figure out which leaf node is closer
    double oneDist, twoDist, closerDist;
    oneDist = parentPt.distance(onePt);
    twoDist = parentPt.distance(twoPt);
   
    if (oneDist < twoDist) {
      closerDist = oneDist;
    } else {
      closerDist = twoDist;
    }
   
    closerDist /= 2;
   
    // figure out which sub-cluster is bigger
    Point2D biggerPt;
    Cluster biggerClus, smallerClus;
    // find the distance between the parent and the node with more weight
    if (leafCluster.getWeight() > clus.getWeight()) {
      biggerPt = onePt;
      biggerClus = leafCluster;
      smallerClus = clus;
    } else {
      biggerPt = twoPt;
      biggerClus = clus.twoCluster;
      smallerClus = clus.oneCluster;
    }
   
    double biggerDist = parentPt.distance(biggerPt);
     
    // create the new, intermediate node

    //newNode.setChildCluster(clus);
    //clus.setRenderedNode(newNode);
   
    // if closerDist is small, bigFraction is 0, so we want
    // the parentFraction to be big.
    double bigFraction, parentFraction;
    if ((closerDist == 0) && (biggerDist == 0)) {
      System.out.println("Returning parent! " + parent + " with clus " + parentCluster);
      return parent;
    } else {
      bigFraction = closerDist/biggerDist;
      parentFraction = 1 - bigFraction;
   
   
      // set the newPt location to be newFraction of the way
      // between parentPt and biggerPt
      double x = parentPt.getX()*parentFraction+biggerPt.getX()*bigFraction;
      double y = parentPt.getY()*parentFraction+biggerPt.getY()*bigFraction;
          Node newNode = new Node(x, y);     

      //System.out.println("MixedCluster1: x: " + x + " y:" + y + " "+ newNode);
     
     
View Full Code Here

                    Cluster oneCluster, Cluster twoCluster) {
    //System.out.println("TwoCluster Process: " + parent);
    //System.out.println(" oneCluster: " + oneCluster + " twoCluster " + twoCluster);
   
   
    Point2D parentPt = parent.getLocation();
    GraphicsGems.checkNaN(parentPt);

//    twoPoint is a point between the parentPoint and the centerPoint
    Line2D parent2OneCenter = new Line2D.Double(parentPt, oneCluster.center);
    Point2D onePt = GraphicsGems.closestIntersectBox(oneCluster.bounds, parent2OneCenter, parentPt);
    //System.out.println("Multiroot_clusterlayout " + oneCluster.bounds + " " + parent2OneCenter + " " + parentPt);
    GraphicsGems.checkNaN(onePt);
   
//    twoPoint is a point between the parentPoint and the centerPoint
    Line2D parent2TwoCenter = new Line2D.Double(parentPt, twoCluster.center);
    Point2D twoPt = GraphicsGems.closestIntersectBox(twoCluster.bounds, parent2TwoCenter, parentPt);
    GraphicsGems.checkNaN(twoPt);
   
    //System.out.println("onePt: " + onePt + " twoPt: " + twoPt);
    // figure out which leaf node is closer
    double oneDist, twoDist, closerDist;
    oneDist = parentPt.distance(onePt);
    twoDist = parentPt.distance(twoPt);
   
    if (oneDist < twoDist) {
      closerDist = oneDist;
    } else {
      closerDist = twoDist;
    }
   
    closerDist /= 2;
   
    // figure out which sub-cluster is bigger
    Point2D biggerPt;
    Cluster biggerClus, smallerClus;
    // find the distance between the parent and the node with more weight
    if (oneCluster.getWeight() > twoCluster.getWeight()) {
      biggerPt = onePt;
      biggerClus = oneCluster;
      smallerClus = twoCluster;
    } else {
      biggerPt = twoPt;
      biggerClus = twoCluster;
      smallerClus = oneCluster;
    }
   
    double biggerDist = parentPt.distance(biggerPt);
      //System.out.println("parentPt " + parentPt + " biggerPoint: " + biggerPt);
    // create the new, intermediate node

    //newNode.setChildCluster(biggerClus);
    //biggerClus.setRenderedNode(newNode);
   
    // if closerDist is small, bigFraction is 0, so we want
    // the parentFraction to be big.
    //System.out.println("closerDist: " + closerDist + " biggerDist: " + biggerDist);
    double bigFraction, parentFraction;
    if ((closerDist == 0) && (biggerDist == 0)) {
      //since points are so close, just return parent
      //System.out.println("Returning parent! " + parent + " with clus " + parentCluster);
     
      return parent;
    } else {
      bigFraction = closerDist/biggerDist;
      parentFraction = 1 - bigFraction;
      //System.out.println("bigFraction: " + bigFraction + " and parentFraction: " + parentFraction);
     
   
      // set the newPt location to be newFraction of the way
      // between parentPt and biggerPt
      double x = parentPt.getX()*parentFraction+biggerPt.getX()*bigFraction;
      double y = parentPt.getY()*parentFraction+biggerPt.getY()*bigFraction;
        Node newNode = new Node(x, y);
 
     
      // update the edge information
      Edge parent2New = new Edge(parent, newNode, parentCluster.getWeight());
View Full Code Here

    twoCluster = two;
     
    // merging leaf nodes
    if ((one.leafNode != null) && (two.leafNode != null)) {
      // make a rectangle that bounds the two nodes
      Point2D onePt = one.leafNode.getLocation();
      bounds = new Rectangle2D.Double(onePt.getX(), onePt.getY(), 0, 0);
      bounds.add(two.leafNode.getLocation());
    } else { // merging non-leaf nodes
      bounds = new Rectangle2D.Double()
     
      if (one.bounds != null && two.bounds != null) {
View Full Code Here

    if(!line1.intersectsLine(line2)){
      //System.out.println("No Intersection!1");
      return new Point2D.Double(Double.POSITIVE_INFINITY,Double.POSITIVE_INFINITY);
    }
   
    Point2D localPoint = new Point2D.Double(0, 0);
   
    double num = (line2.getP2().getY()-line2.getP1().getY())*(line2.getP1().getX()-line1.getP1().getX()) -
    (line2.getP2().getX()-line2.getP1().getX())*(line2.getP1().getY()-line1.getP1().getY());
   
    double denom = (line2.getP2().getY()-line2.getP1().getY())*(line1.getP2().getX()-line1.getP1().getX()) -
    (line2.getP2().getX()-line2.getP1().getX())*(line1.getP2().getY()-line1.getP1().getY());
   
    double t = num/denom;
    if(t < 0 || t > 1){
      //System.out.println("No Intersection!2");
      return new Point2D.Double(Double.POSITIVE_INFINITY,Double.POSITIVE_INFINITY);
    }
   
    double x = line1.getP1().getX() + (line1.getP2().getX()-line1.getP1().getX())*t;
    double y = line1.getP1().getY() + (line1.getP2().getY()-line1.getP1().getY())*t;
    localPoint.setLocation(x, y);
   
    //System.out.println("Intersection at: " + localPoint);
    return localPoint;
  }
View Full Code Here

   * @param line1
   * @param line2
   * @return
   */
  public static Point2D intersectInfiniteLines(Line2D line1, Line2D line2) {
    Point2D localPoint = new Point2D.Double(0, 0);
   
    double num = (line2.getP2().getY()-line2.getP1().getY())*(line2.getP1().getX()-line1.getP1().getX()) -
    (line2.getP2().getX()-line2.getP1().getX())*(line2.getP1().getY()-line1.getP1().getY());
   
    double denom = (line2.getP2().getY()-line2.getP1().getY())*(line1.getP2().getX()-line1.getP1().getX()) -
    (line2.getP2().getX()-line2.getP1().getX())*(line1.getP2().getY()-line1.getP1().getY());
   
    double t = num/denom;
    double x = line1.getP1().getX() + (line1.getP2().getX()-line1.getP1().getX())*t;
    double y = line1.getP1().getY() + (line1.getP2().getY()-line1.getP1().getY())*t;
    localPoint.setLocation(x, y);
   
    //System.out.println("Intersection at: " + localPoint);
    return localPoint;
  }
View Full Code Here

   * @param point
   * @return the closest point on the boundary of rect that is on line, measured from point
   */
  public static Point2D closestIntersectBox(Rectangle2D rect, Line2D line, Point2D point) {
    //System.out.println("Looking at box: " + rect + " line from " + line.getP1() + " to " + line.getP2() + " and point " + point);
    Point2D closest, candidate;
    double closestDist, candidateDist;
   
   
    Point2D topLeft = new Point2D.Double(rect.getX(), rect.getY());
    Point2D topRight = new Point2D.Double(rect.getX()+rect.getWidth(), rect.getY());
    Point2D bottomLeft = new Point2D.Double(rect.getX(), rect.getY()+rect.getHeight());
    Point2D bottomRight = new Point2D.Double(rect.getX()+rect.getWidth(),rect.getY()+rect.getHeight() );
   
   
    // top of rectangle
    Line2D top = new Line2D.Double(topLeft, topRight);
    closest = intersectSegments(line, top);
View Full Code Here

TOP

Related Classes of org.codemap.util.geom.Point2D$Float

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.