/**
     * 获取到像素坐标点
     *
     * @param bitmap
     * @return
     */
    public static Map<Integer, List<Point>> getCoordinateData(Bitmap bitmap) {
        if (bitmap == null) {
            Log.e(TAG, "getCoordinateData() called with: bitmap is null");
            return null;
        }
        //获得缩放后的宽高
        int width = bitmap.getWidth();
        int height = bitmap.getHeight();
        Log.d(TAG, "getRegenBitmap after compress: width = " + width + ",height = " + height);

        // 2. 判断颜色比较遍历像素 并填充替换=====
        // 保存所有的像素的数组，图片宽×高
        int[] pixels = new int[width * height];

        bitmap.getPixels(pixels, 0, width, 0, 0, width, height);

        int length = pixels.length;

        Map<Integer, List<Point>> map = new HashMap<>();
        List<Point> listY = new ArrayList<>();
        List<Point> listW = new ArrayList<>();
        List<Point> listG = new ArrayList<>();
        Point point;

        for (int i = 0; i < length; i++) {
            int clr = pixels[i];
            int red = Color.red(clr);
            int green = Color.green(clr);
            int blue = Color.blue(clr);

            if (isArrow(red, green, blue)) { //箭头黄色
                pixels[i] = Color.YELLOW;
                point = new Point();
                point.y = i / width;
                point.x = i % width;
                listY.add(point);
            } else if (isWhite(red, green, blue)) {//线条白色
//                pixels[i] = Color.WHITE;
                pixels[i] = Color.GRAY;
                point = new Point();
                point.y = i / width;
                point.x = i % width;
                listG.add(point);
//                listW.add(point);
            } else if (isBuilding(red, green, blue)) {//建筑灰色
                pixels[i] = Color.GRAY;
                point = new Point();
                point.y = i / width;
                point.x = i % width;
                listG.add(point);
            } else if (isBlue(red, green, blue)) { //道路黑色
                pixels[i] = Color.BLACK;
            } else {
                //其他默认黑色
                pixels[i] = Color.BLACK;
            }
        }

//        ImageUtils.save(Bitmap.createBitmap(pixels, width, height, Bitmap.Config.RGB_565),
//                (PathUtils.getInternalAppCachePath() + File.separator + "cross1.png")
//                , Bitmap.CompressFormat.PNG);
        map.put(1, listY);
        map.put(2, listW);
        map.put(3, listG);
        return map;
    }
    
 /**
     * RLE行程压缩算法
     */
    public static class RLEPoint {
        private int len = 1; //为了确保只有1字节，点的个数最多127
        private Point startPoint;

        public int getLen() {
            return len;
        }

        public Point getStartPoint() {
            return startPoint;
        }

        @Override
        public String toString() {
            return "{len = " + len + ", start:" + startPoint + "}";
        }
    }
    
  /**
     * 使用RLE行程长度编码压缩，(按照纵坐标来压)
     *
     * @param originPoints
     * @return
     */
    public static Map<Integer, List<RLEPoint>> covertRLEPoint(Map<Integer, List<Point>> originPoints) {
        Map<Integer, List<RLEPoint>> dest = new HashMap<>();

        Iterator<Map.Entry<Integer, List<Point>>> iterator = originPoints.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer, List<Point>> entry = iterator.next();
            Integer key = entry.getKey();
            List<Point> points = entry.getValue();

            dest.put(key, convertPoint2RLE(points));
        }
        return dest;
    }


    /**
     * 扩展RLE, 相同长度的再合并, 减少那些散点
     *
     * @param originRLEPoints
     * @return
     */
    public static Map<Integer, List<RLEPointsExt>> covertRLEPointExt(Map<Integer, List<RLEPoint>> originRLEPoints) {
        Map<Integer, List<RLEPointsExt>> dest = new HashMap<>();

        Iterator<Map.Entry<Integer, List<RLEPoint>>> iterator = originRLEPoints.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer, List<RLEPoint>> entry = iterator.next();
            Integer key = entry.getKey();
            List<RLEPoint> points = entry.getValue();

            dest.put(key, convertRLEPoint2Ext(points));
        }
        return dest;
    }

//获取到需要的像素坐标点
       Map<Integer, List<Point>> picData = CrossBitmapUtil.getCoordinateData(newBitmap);

       /**使用RLE行程长度来对像素坐标点进行编码压缩(按照纵坐标来压)**/
       Map<Integer, List<CrossBitmapUtil.RLEPoint>> rlePoints = CrossBitmapUtil.covertRLEPoint(picData);

       /**扩展RLE, 相同长度的再合并, 减少那些散点**/
       Map<Integer, List<CrossBitmapUtil.RLEPointsExt>> rleDataExt = CrossBitmapUtil.covertRLEPointExt(rlePoints);

       Set<Integer> keySet = rleDataExt.keySet();
       size += keySet.size(); /** NByte: Color **/

       Collection<List<CrossBitmapUtil.RLEPointsExt>> values = rleDataExt.values();
       for (List<CrossBitmapUtil.RLEPointsExt> segments : values) {//RLE Ext segments
           size += 1;/** 1Byte: segments **/
           for (CrossBitmapUtil.RLEPointsExt ext : segments) {
               size += 1;/** 1Byte: RLE Len **/
               size += 2;/** 2Byte: Point Count **/
               size += 2 * ext.getPoints().size();  /** NByte: Points **/
           }
       }