Ejemplo n.º 1
0
  /** Generates array of XContour from local contours and modules. Used for TTF building. */
  private XContour[] toContours() {
    XContour[] retval;
    ArrayList<XContour> list = new ArrayList<>();
    XContour[] contours = m_glyph.getBody().getContour();
    for (int i = 0; i < contours.length; i++) {
      EContour contour = (EContour) contours[i];
      list.add(contour.toQuadratic());
    } // for i

    XModule[] modules = m_glyph.getBody().getModule();
    for (int i = 0; i < modules.length; i++) {
      EModuleInvoke module = (EModuleInvoke) modules[i];

      // push and pop happens inside toContour
      list.add(module.toContour(new AffineTransform()));
    } // for i

    if (list.size() == 0) return null;

    retval = new XContour[list.size()];
    for (int i = 0; i < list.size(); i++) {
      retval[i] = list.get(i);
    } // for i

    return retval;
  }
Ejemplo n.º 2
0
 public void checkStarCollision() {
   for (Star s : starList) {
     if (s.getOnScreen()) { // if the star is on the screen we need to check if player collides
       if (s.checkCollision(
           s.getPics().get(s.getCounter()),
           player1)) { // if the player collides with the star we remove it then change the
         // velosity to the distance that the star provides
         sRemove.add(s); // remove star once you collide with it
         player1.setVelo(s.getDist()); // changes the velocity
         player1.setInvi(true); // sets the player invisble for a few seconds
         score += s.getPoints(); // points increase by the star type
         if (musicOn) {
           starSound.play(); // playthe star sound
         }
       }
     } else {
       sRemove.add(s); // remove the star if its not on the screen
     }
   }
   for (Star s : sRemove) {
     poofList.add(new Poof(s.getX(), s.getY(), s.getNum() + 3)); // make the poof effect
     starList.remove(s);
   }
   sRemove = new ArrayList<Star>();
 }
Ejemplo n.º 3
0
 // -------------------------------------------------------------------------------------------------------------------------------------------------------
 // Decorations
 public void newDecos() {
   int prob = (int) (Math.random() * 100); // randomly spawnst he decoration
   if (prob == 1) {
     if (decoList.size() < 1) {
       int prob2 = (int) (Math.random() * 2);
       if (prob2 == 1) { // right side or left side
         decoList.add(new Decorations(-700, (int) (backy * 0.1) % 23080, false));
       } else {
         decoList.add(new Decorations(-700, (int) (backy * 0.1) % 23080, true));
       }
     }
   }
   Boolean check = true;
   for (Decorations i : decoList) {
     if (i.getYTop() >= 2000) {
       check = false;
       break;
     }
   }
   if (check == false
       && decoList.size()
           > 0) { // theres only on in the lsit but for consitency we kept it as a list
     decoList.remove(0);
   }
 }
Ejemplo n.º 4
0
 public void checkEnemyCollision() {
   for (Enemy e : enemyList) {
     if (e.getOnScreen()) { // can be removed later on
       // goes through all the enemies and checks if they collide
       if (e.checkCollision(e.getPics().get(e.getCounter()), player1)) {
         if (player1.getInvi() == false) {
           // If the player is not invisble then you get spiked.
           if (player1.getVelocity() > 0) { // if the player hits it from the bottom
             player1.setSpikeVelo();
             loseCoins();
           } else {
             player1.setVelo(
                 50); // if the player is on top instead the player bounces off the enemy
             if (musicOn) {
               bounce.play();
             }
           }
         }
         eRemove.add(e); // once we hit, we remove the enemy
       }
     } else {
       eRemove.add(e); // if the enemy goes of the screen, we remove
     }
   }
   for (Enemy e : eRemove) {
     poofList.add(new Poof(e.getX(), e.getY(), 1)); // removes all the enemies
     enemyList.remove(e);
   }
   eRemove = new ArrayList<Enemy>();
 }
 public void curveTo(float x1, float y1, float x2, float y2, float x3, float y3) {
   gp.curveTo(x1, y1, x2, y2, x3, y3);
   this.x = x3;
   this.y = y3;
   points.add(new GlyphPoint(x1, y1, true));
   points.add(new GlyphPoint(x2, y2, true));
   points.add(new GlyphPoint(x3, y3, false));
 }
Ejemplo n.º 6
0
  /**
   * Returns the list of selected points.
   *
   * @return list of selected points
   */
  public List<WhiteboardPoint> getSelectionPoints() {
    ArrayList<WhiteboardPoint> selectionPoints = new ArrayList<WhiteboardPoint>();

    selectionPoints.add(startPoint);
    selectionPoints.add(endPoint);

    return selectionPoints;
  }
Ejemplo n.º 7
0
    // Generates a new polygon by dragging a polygon through an angle, and taking all the points it
    // touched (and a few extras for overestimation)
    // Only valid for convex polygons, and small rotations (20 degrees or less)
    // stroke from theta1 to theta2
    public static Polygon strokeRot(double theta1, double theta2, Polygon poly) {
      Polygon poly1 = mul(Mat.rotation(theta1), poly);
      Polygon poly2 = mul(Mat.rotation(theta2), poly);
      Polygon stroked = combine(poly1, poly2);
      ArrayList<Mat> cornerVerts;
      Polygon corner;
      int thisVertex, prevVertex, nextVertex;
      Mat origin = Mat.encodePoint(0, 0);
      Mat cornerVert1a, cornerVert1b;
      Mat cornerVert2a, cornerVert2b;
      double actualDist, desiredDist;
      Mat cornerTransform;
      for (thisVertex = 0; thisVertex < poly.vertices.size(); thisVertex++) {
        if (thisVertex == 0) {
          prevVertex = poly.vertices.size() - 1;
        } else {
          prevVertex = thisVertex - 1;
        }

        if (thisVertex == poly.vertices.size() - 1) {
          nextVertex = 0;
        } else {
          nextVertex = thisVertex + 1;
        }

        cornerVerts = new ArrayList<Mat>();
        cornerVerts.add(poly2.vertices.get(nextVertex));
        cornerVerts.add(origin);
        cornerVerts.add(poly1.vertices.get(prevVertex));

        cornerVert1a = poly1.vertices.get(thisVertex);
        cornerVert2a = poly2.vertices.get(thisVertex);

        actualDist = ptSegDistance(cornerVert1a, cornerVert2a, origin);
        desiredDist = Mat.dist(cornerVert1a, Mat.encodePoint(0, 0));

        cornerTransform = Mat.mul(desiredDist / actualDist, Mat.eye(4));
        cornerVert1b = Mat.mul(cornerTransform, cornerVert1a);
        cornerVert2b = Mat.mul(cornerTransform, cornerVert2a);

        cornerVert1b =
            lineSegIntersection(
                cornerVert1b, cornerVert2b, poly1.vertices.get(prevVertex), cornerVert1a);
        cornerVert2b =
            lineSegIntersection(
                cornerVert1b, cornerVert2b, poly2.vertices.get(nextVertex), cornerVert2a);

        cornerVerts.add(cornerVert1b);
        cornerVerts.add(cornerVert2b);

        corner = new Polygon(cornerVerts);
        stroked = combine(stroked, corner);
      }

      return stroked;
    }
Ejemplo n.º 8
0
  /**
   * Recalculates the selection points coordinates and adds the new selection points to the list of
   * selection points.
   */
  private void recalculateSelectionPoints() {
    selectionPoints.clear();

    selectionPoints.add(new WhiteboardPoint(point.getX(), point.getY()));

    selectionPoints.add(new WhiteboardPoint(point.getX() + width, point.getY()));

    selectionPoints.add(new WhiteboardPoint(point.getX(), point.getY() + height));

    selectionPoints.add(new WhiteboardPoint(point.getX() + width, point.getY() + height));
  }
Ejemplo n.º 9
0
  private ArrayList GetFolderTree(String s_Dir, String s_Flag, int n_Indent, int n_TreeIndex) {
    String s_List = "";
    ArrayList aSubFolders = new ArrayList();

    File file = new File(s_Dir);
    File[] filelist = file.listFiles();

    if (filelist != null && filelist.length > 0) {
      for (int i = 0; i < filelist.length; i++) {
        if (filelist[i].isDirectory()) {
          aSubFolders.add(filelist[i].getName());
        }
      }

      int n_Count = aSubFolders.size();
      String s_LastFlag = "";
      String s_Folder = "";
      for (int i = 1; i <= n_Count; i++) {
        if (i < n_Count) {
          s_LastFlag = "0";
        } else {
          s_LastFlag = "1";
        }

        s_Folder = aSubFolders.get(i - 1).toString();
        s_List =
            s_List
                + "arr"
                + s_Flag
                + "["
                + String.valueOf(n_TreeIndex)
                + "]=new Array(\""
                + s_Folder
                + "\","
                + String.valueOf(n_Indent)
                + ", "
                + s_LastFlag
                + ");\n";
        n_TreeIndex = n_TreeIndex + 1;
        ArrayList a_Temp =
            GetFolderTree(s_Dir + s_Folder + sFileSeparator, s_Flag, n_Indent + 1, n_TreeIndex);
        s_List = s_List + a_Temp.get(0).toString();
        n_TreeIndex = Integer.valueOf(a_Temp.get(1).toString()).intValue();
      }
    }

    ArrayList a_Return = new ArrayList();
    a_Return.add(s_List);
    a_Return.add(String.valueOf(n_TreeIndex));
    return a_Return;
  }
Ejemplo n.º 10
0
 // -------------------------------------------------------------------------------------------------------------------------------------------------------
 // Patterns
 public void newPattern() {
   int prob = (int) (Math.random() * probs.get(level - 1) + 1);
   Pattern p = new Pattern(0, -300, prob, (int) (backy * 0.1));
   if (checkSpawn(new Rectangle(p.getX(), p.getY(), p.getWidth(), p.getHeight())) == true) {
     for (Coin i : p.getCoins()) {
       coinList.add(i);
     }
     for (Star i : p.getStars()) {
       starList.add(i);
     }
     for (Box i : p.getBoxes()) {
       boxList.add(i);
     }
     for (Jumper i : p.getJumpers()) {
       jumperList.add(i);
     }
     for (Enemy i : p.getEnemies()) {
       enemyList.add(i);
     }
     for (Spikes i : p.getSpikes()) {
       spikeList.add(i);
     }
     for (Powerup i : p.getPowerUps()) {
       pupList.add(i);
     }
     for (Rectangle i : p.getRects()) {
       rectList.add(i);
     }
   }
 }
Ejemplo n.º 11
0
 private ArrayList<Integer> findRanges() {
   int rowsPerRange = (int) Math.ceil((grid.size()) / (double) threads);
   ArrayList<Integer> ranges = new ArrayList<Integer>();
   int startRow = 0, endRow = rowsPerRange;
   for (int i = 0; i < threads; i++) {
     ranges.add(startRow);
     ranges.add(endRow);
     startRow = endRow;
     ;
     endRow += rowsPerRange;
   }
   ranges.set(ranges.size() - 1, Math.min(grid.size(), ranges.get(ranges.size() - 1)));
   System.out.println(ranges);
   return ranges;
 }
Ejemplo n.º 12
0
 // Transform a polygon by a matrix
 public static Polygon mul(Mat matrix, Polygon poly) {
   ArrayList<Mat> newVertices = new ArrayList<Mat>();
   for (Mat vertex : poly.vertices) {
     newVertices.add(Mat.mul(matrix, vertex));
   }
   return new Polygon(newVertices);
 }
 public TestType1CFont(InputStream is) throws IOException {
   super();
   setPreferredSize(new Dimension(800, 800));
   addKeyListener(this);
   BufferedInputStream bis = new BufferedInputStream(is);
   int count = 0;
   ArrayList<byte[]> al = new ArrayList<byte[]>();
   byte b[] = new byte[32000];
   int len;
   while ((len = bis.read(b, 0, b.length)) >= 0) {
     byte[] c = new byte[len];
     System.arraycopy(b, 0, c, 0, len);
     al.add(c);
     count += len;
     b = new byte[32000];
   }
   data = new byte[count];
   len = 0;
   for (int i = 0; i < al.size(); i++) {
     byte from[] = al.get(i);
     System.arraycopy(from, 0, data, len, from.length);
     len += from.length;
   }
   pos = 0;
   //	printData();
   parse();
   // TODO: free up (set to null) unused structures (data, subrs, stack)
 }
Ejemplo n.º 14
0
 public ArrayList<Polygon> getCSObstacles() {
   ArrayList<Polygon> csObstacles = new ArrayList<Polygon>();
   for (Polygon obstacle : obstacles) {
     csObstacles.add(Polygon.minkowskiSumSimple(obstacle, reflectedRobot));
   }
   return csObstacles;
 }
Ejemplo n.º 15
0
    public static boolean pointInPolygon(Polygon poly, Mat point) {
      ArrayList<Point2D.Double> points = new ArrayList<Point2D.Double>();
      for (Mat v : poly.vertices) {
        points.add(new Point2D.Double(v.data[0][0], v.data[1][0]));
      }
      PolygonObstacle po = GeomUtils.convexHull(points);
      return po.contains(point.data[0][0], point.data[1][0]);

      /*Mat farPoint = Mat.encodePoint(0, 0);
      double maxDist = -1;
      double dist;

      for (Mat vertex : poly.vertices) {
      	dist = Mat.dist(point, vertex);
      	if (maxDist < dist) {
      		maxDist = dist;
      	}
      }

      farPoint = Mat.add(point, Mat.mul(maxDist + 1, Mat.encodePoint(1, 0)));

      int size = poly.vertices.size();
      int intersections = 0;
      for (int i = 0; i < size; i++) {
      	if (lineSegIntersect(point, farPoint, poly.vertices.get(i), poly.vertices.get((i + 1) % size))) {
      		intersections++;
      	}
      }

      return ((intersections % 2) == 1);*/
    }
Ejemplo n.º 16
0
 public void manageStuff() {
   // organizes the the stuff in the stats list to useable stuff
   int c = 0;
   money = Integer.parseInt(stats.get(c));
   c++;
   for (int i = 0; i < Integer.parseInt(stats.get(1)); i++) {
     powerUps.add(stats.get(i + 2));
     c++;
   }
   c++;
   // System.out.println(Integer.parseInt(stats.get(1))+1);
   // System.out.println(c);
   for (int i = c + 1; i < c + Integer.parseInt(stats.get(c)) + 1; i++) {
     chars.add(stats.get(i));
   }
 }
Ejemplo n.º 17
0
 public void addObstacle(PolygonObstacle obstacle) {
   ArrayList<Mat> vertices = new ArrayList<Mat>();
   for (Point2D.Double vert : obstacle.getVertices()) {
     vertices.add(Mat.encodePoint(vert.x, vert.y));
   }
   addObstacle(new Polygon(vertices));
 }
Ejemplo n.º 18
0
 public void sendToBack(Figure figure) {
   if (children.remove(figure)) {
     children.add(0, figure);
     needsSorting = true;
     fireAreaInvalidated(figure.getDrawingArea());
   }
 }
Ejemplo n.º 19
0
  public int cleanUpTaxiwayParking() {
    ArrayList arrayList = new ArrayList();
    Iterator iterator = taxiwayParkingHM.keySet().iterator();
    do {
      if (!iterator.hasNext()) break;
      int index = ((Integer) iterator.next()).intValue();
      boolean found = false;
      int i = taxiwayPathAL.size() - 1;
      do {
        if (i < 0) break;
        TaxiwayPathModel taxiwayPathModel = (TaxiwayPathModel) taxiwayPathAL.get(i);
        if (taxiwayPathModel.getType().equals("PARKING") && taxiwayPathModel.getEnd() == index) {
          found = true;
          break;
        }
        i--;
      } while (true);
      if (!found) arrayList.add(taxiwayParkingHM.get(new Integer(index)));
    } while (true);
    int totalDeleted = arrayList.size();
    for (int i = arrayList.size() - 1; i >= 0; i--)
      removeTaxiwayParkingModel((TaxiwayParkingModel) arrayList.get(i));

    return totalDeleted;
  }
Ejemplo n.º 20
0
 public void bringToFront(Figure figure) {
   if (children.remove(figure)) {
     children.add(figure);
     needsSorting = true;
     fireAreaInvalidated(figure.getDrawingArea());
   }
 }
Ejemplo n.º 21
0
  public TTGlyph toSimpleGlyph() {
    // convert the file into array of contours
    XContour[] contours = toContours();
    if ((contours == null) && (!isRequiredGlyph())) {
      return null;
    } // if

    TTGlyph retval = new TTGlyph();
    retval.setSimple(true);
    retval.setAdvanceWidth(getAdvanceWidth());

    if (contours == null) {
      return retval;
    } // if

    ArrayList<EContourPoint> points = new ArrayList<>();
    for (int i = 0; i < contours.length; i++) {
      XContour contour = contours[i];
      XContourPoint[] contourPoints = contour.getContourPoint();
      for (int j = 0; j < contourPoints.length; j++) {
        points.add((EContourPoint) contourPoints[j]);
      } // for j
      retval.addEndPoint(points.size() - 1);
    } // for i

    for (EContourPoint point : points) {
      loadContourPoint(retval, point);
    } // for point

    boolean hasGridfit = false;
    // I need int i here.
    for (int i = 0; i < points.size(); i++) {
      EContourPoint point = points.get(i);

      if (!point.isRounded()) {
        continue;
      } // if

      hasGridfit = true;
      loadGridfit(retval, point, i);
    } // for i

    if (hasGridfit) {
      retval.addInstruction(TTGlyph.IUP1);
      retval.addInstruction(TTGlyph.IUP0);
    } // if

    // I need int i here.
    for (int i = 0; i < points.size(); i++) {
      EContourPoint point = points.get(i);
      if (point.getHint().length == 0) {
        continue;
      } // if

      loadHint(retval, point, i);
    } // for i

    return retval;
  }
Ejemplo n.º 22
0
  public BufferedImage filter(BufferedImage src, BufferedImage dst) {
    if (dst == null) dst = createCompatibleDestImage(src, null);

    int width = src.getWidth();
    int height = src.getHeight();
    int numScratches = (int) (density * width * height / 100);
    ArrayList<Line2D> lines = new ArrayList<Line2D>();
    {
      float l = length * width;
      Random random = new Random(seed);
      Graphics2D g = dst.createGraphics();
      g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      g.setColor(new Color(color));
      g.setStroke(new BasicStroke(this.width));
      for (int i = 0; i < numScratches; i++) {
        float x = width * random.nextFloat();
        float y = height * random.nextFloat();
        float a = angle + ImageMath.TWO_PI * (angleVariation * (random.nextFloat() - 0.5f));
        float s = (float) Math.sin(a) * l;
        float c = (float) Math.cos(a) * l;
        float x1 = x - c;
        float y1 = y - s;
        float x2 = x + c;
        float y2 = y + s;
        g.drawLine((int) x1, (int) y1, (int) x2, (int) y2);
        lines.add(new Line2D.Float(x1, y1, x2, y2));
      }
      g.dispose();
    }

    if (false) {
      //		int[] inPixels = getRGB( src, 0, 0, width, height, null );
      int[] inPixels = new int[width * height];
      int index = 0;
      for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
          float sx = x, sy = y;
          for (int i = 0; i < numScratches; i++) {
            Line2D.Float l = (Line2D.Float) lines.get(i);
            float dot = (l.x2 - l.x1) * (sx - l.x1) + (l.y2 - l.y1) * (sy - l.y1);
            if (dot > 0) inPixels[index] |= (1 << i);
          }
          index++;
        }
      }

      Colormap colormap = new LinearColormap();
      index = 0;
      for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
          float f = (float) (inPixels[index] & 0x7fffffff) / 0x7fffffff;
          inPixels[index] = colormap.getColor(f);
          index++;
        }
      }
      setRGB(dst, 0, 0, width, height, inPixels);
    }
    return dst;
  }
Ejemplo n.º 23
0
 // assumes that there will be no enclosed empty spaces in the result, and that the result will
 // be contiguous, and that everything is convex
 public static Polygon minkowskiSumSimple(Polygon poly1, Polygon poly2) {
   ArrayList<Mat> verts = new ArrayList<Mat>();
   for (Mat v1 : poly1.vertices) {
     for (Mat v2 : poly2.vertices) {
       verts.add(Mat.add(v1, v2));
     }
   }
   ArrayList<Point2D.Double> points = new ArrayList<Point2D.Double>();
   for (Mat v : verts) {
     points.add(new Point2D.Double(v.data[0][0], v.data[1][0]));
   }
   PolygonObstacle po = GeomUtils.convexHull(points);
   verts = new ArrayList<Mat>();
   for (Point2D.Double vert : po.getVertices()) {
     verts.add(Mat.encodePoint(vert.x, vert.y));
   }
   return new Polygon(verts);
 }
Ejemplo n.º 24
0
  public ArrayList getVORdmeModels() {
    ArrayList arrayList = new ArrayList();
    for (int i = vorAL.size() - 1; i >= 0; i--) {
      VORModel vorModel = (VORModel) vorAL.get(i);
      if (vorModel.getDme()) arrayList.add(vorModel.getDMEModel());
    }

    return arrayList;
  }
Ejemplo n.º 25
0
 /** Implementation note: Sorting can not be done for orphaned children. */
 public java.util.List<Figure> sort(Collection<Figure> c) {
   ensureSorted();
   ArrayList<Figure> sorted = new ArrayList<Figure>(c.size());
   for (Figure f : children) {
     if (c.contains(f)) {
       sorted.add(f);
     }
   }
   return sorted;
 }
Ejemplo n.º 26
0
 protected Iterable<? extends LatLon> computeDrawLocations(
     DrawContext dc, SurfaceTileDrawContext sdc) {
   ArrayList<LatLon> drawList = new ArrayList<LatLon>();
   double safeDistanceDegreesSquared = Math.pow(this.computeSafeRadius(dc, sdc).degrees, 2);
   for (LatLon location : this.getLocations()) {
     if (this.computeLocationDistanceDegreesSquared(sdc.getSector(), location)
         <= safeDistanceDegreesSquared) drawList.add(location);
   }
   return drawList;
 }
Ejemplo n.º 27
0
 // -------------------------------------------------------------------------------------------------------------------------------------------------------
 // Poofs
 public void removePoof() { // once the poof animation is the poof is removed from the list
   for (Poof p : poofList) {
     if (p.isDone()) {
       pRemove.add(p);
     }
   }
   for (Poof p : pRemove) {
     poofList.remove(p);
   }
   pRemove = new ArrayList<Poof>();
 }
Ejemplo n.º 28
0
  public ArrayList getILSDMEModels() {
    ArrayList arrayList = new ArrayList();
    for (int i = runwayAL.size() - 1; i >= 0; i--) {
      RunwayModel runwayModel = (RunwayModel) runwayAL.get(i);
      for (int j = runwayModel.getILSAL().size() - 1; j >= 0; j--)
        if (((ILSModel) runwayModel.getILSAL().get(j)).getDMEModel() != null)
          arrayList.add(((ILSModel) runwayModel.getILSAL().get(j)).getDMEModel());
    }

    return arrayList;
  }
Ejemplo n.º 29
0
 public void checkSpikeCollision() { // checks the spike collision
   for (Spikes s : spikeList) {
     if (s.getOnScreen()) { // if the spike is on the screen
       if (s.checkCollision(s.getImage(), player1)) { // if the user collides with the spike
         if (player1.getInvi() == false) { // if player is not invisiblity
           player1.setSpikeVelo(); // set the spike velocity
           loseCoins();
           player1.setDown(true);
         }
         spRemove.add(s);
       }
     } else {
       spRemove.add(s); // remove the spike
     }
   }
   for (Spikes s : spRemove) {
     spikeList.remove(s);
   }
   spRemove = new ArrayList<Spikes>();
 }
Ejemplo n.º 30
0
 public void addTaxiwayPathDisplayModel(
     TaxiwayPathDisplayModel taxiwayPathDisplayModel, boolean parking) {
   if (!taxiwayPathDisplayModel.isDisplayed()) return;
   Integer start = new Integer(taxiwayPathDisplayModel.getStart());
   Integer end = new Integer(taxiwayPathDisplayModel.getEnd());
   if (!parking)
     if (taxiwayPathDisplayHM.containsKey(end)) {
       ((ArrayList) taxiwayPathDisplayHM.get(end)).add(taxiwayPathDisplayModel);
     } else {
       ArrayList arrayList = new ArrayList();
       arrayList.add(taxiwayPathDisplayModel);
       taxiwayPathDisplayHM.put(end, arrayList);
     }
   if (taxiwayPathDisplayHM.containsKey(start)) {
     ((ArrayList) taxiwayPathDisplayHM.get(start)).add(taxiwayPathDisplayModel);
   } else {
     ArrayList arrayList = new ArrayList();
     arrayList.add(taxiwayPathDisplayModel);
     taxiwayPathDisplayHM.put(start, arrayList);
   }
   taxiwayPathDisplayAL.add(taxiwayPathDisplayModel);
 }