Browse Source

图像单通道拆解

syh 5 years ago
parent
commit
724f3cf692

+ 175 - 76
jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/opencv/CornerCheck.java

@@ -1,12 +1,12 @@
 package org.jeecg.modules.demo.opencv;
 
+import cn.com.ctop.common.module.utils.ResultMapUtils;
+import cn.com.ctop.common.module.utils.StatusCode;
 import org.opencv.core.*;
-import org.opencv.highgui.HighGui;
 import org.opencv.imgcodecs.Imgcodecs;
 import org.opencv.imgproc.Imgproc;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
 
 /**
  * 角点检测
@@ -16,48 +16,33 @@ public class CornerCheck {
         System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
     }
 
+    private static int EXPAND_SIZE = 3;
     public static void main(String[] args) {
 //        harris();
-        detectConers();
-//        getConers();
+//        detectConers();
+        channelSplit();
     }
 
-    public static void getConers() {
-        Mat src = Imgcodecs.imread("D:\\data\\167.jpg");
-        List<Point> points = new ArrayList<>();
-        int minX = 10000;
-        int minY = 10000;
-        int maxX = 0;
-        int maxY = 0;
-        for (int j = 0; j < src.rows(); j++) {
-            for (int i = 0; i < src.cols(); i++) {
-                double[] details = src.get(j, i);
-                if (null != details && details.length > 0) {
-                    if (details[0] == 0 && details[1] == 236 && details[2] == 2) {
-                        System.out.print("{" + j + "," + i + "}:");
-                        Point point = new Point();
-                        point.x = i;
-                        point.y = j;
-                        if (minX >= i) {
-                            minX = i;
-                        }
-                        if (maxX <= i) {
-                            maxX = i;
-                        }
-                        if (maxY <= j) {
-                            maxY = j;
-                        }
-                        points.add(point);
-                    }
-                }
-            }
-        }
+    public static void channelSplit() {
+        Mat srcImage = Imgcodecs.imread("D:\\data\\235.jpg", Imgcodecs.IMREAD_COLOR);
+        List<Mat> channels = new ArrayList<>();
+        Core.split(srcImage, channels);
 
-        System.out.println(minX);
+        //创建类型为Mat,数组长度为3的变量mbgr
+        List<Mat> mbgr = new ArrayList<>();
+        Mat hideChannel = new Mat(srcImage.size(), CvType.CV_8UC1, new Scalar(0));
+
+        Mat imageB = new Mat(srcImage.size(), CvType.CV_8UC3);
+        mbgr.add(channels.get(0));
+        mbgr.add(hideChannel);
+        mbgr.add(hideChannel);
+        Core.merge(mbgr, imageB);
+        Imgcodecs.imwrite("D:\\data\\imageB.jpg", imageB);
 
     }
 
-    public static void detectConers() {
+    public static Map<String, Object> detectConers() {
+        Map<String, Object> result = new HashMap<>();
         try {
             System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
 
@@ -66,65 +51,179 @@ public class CornerCheck {
             final boolean useHarrisDetector = false;
             MatOfPoint corners = new MatOfPoint();
 
-            Mat src = Imgcodecs.imread("D:\\data\\167.jpg");
+            Mat src = Imgcodecs.imread("D:\\data\\235.jpg");
             if (src.empty()) {
                 throw new Exception("no file");
             }
             Mat dst = src.clone();
             Mat gray = new Mat();
+            //灰度
             Imgproc.cvtColor(src, gray, Imgproc.COLOR_RGB2GRAY);
-            Imgproc.goodFeaturesToTrack(gray, corners, maxCorners, qualityLevel, minDistance,
+            Imgcodecs.imwrite("D:\\data\\gray.jpg", gray);
+            Mat binary = new Mat();
+            //二值化
+            Imgproc.threshold(gray, binary, 1, 255, Imgproc.THRESH_TOZERO);
+            Imgcodecs.imwrite("D:\\data\\binary.jpg", binary);
+            Imgproc.goodFeaturesToTrack(binary, corners, maxCorners, qualityLevel, minDistance,
                     new Mat(), blockSize, useHarrisDetector, k);
             Point[] pCorners = corners.toArray();
-
+            List<Point> pointList = new ArrayList<>();
+            double maxX = 0d;
+            double maxY = 0d;
+            double minX = 10000d;
+            double minY = 100000d;
             for (int i = 0; i < pCorners.length; i++) {
-                double[] details = src.get((int) pCorners[i].y, (int) pCorners[i].x);
+                Imgproc.circle(dst, pCorners[i], 4, new Scalar(0, 0, 0), Imgproc.FILLED);
                 if (pCorners[i].x > 130 && pCorners[i].x < 570 && pCorners[i].y > 200 && pCorners[i].y < 850) {
-                    System.out.println(pCorners[i].toString());
-                    Imgproc.circle(dst, pCorners[i], 4, new Scalar(0, 0, 255), Imgproc.FILLED);
+                    if (pCorners[i].x >= maxX) {
+                        maxX = pCorners[i].x;
+                    }
+                    if (pCorners[i].y >= maxY) {
+                        maxY = pCorners[i].y;
+                    }
+
+                    if (pCorners[i].x <= minX) {
+                        minX = pCorners[i].x;
+                    }
+
+                    if (pCorners[i].y <= minY) {
+                        minY = pCorners[i].y;
+                    }
+                    pointList.add(pCorners[i]);
                 }
             }
+            Imgcodecs.imwrite("D:\\data\\allConers.jpg", dst);
+            List<Point> cornerPoints = new ArrayList<>();
+            for (Point point : pointList) {
+                double getX = point.x;
+                double getY = point.y;
+                if ((getY >= (minY + 20) && getY <= (maxY - 20))) {
+                    Imgproc.circle(dst, point, 4, new Scalar(255, 255, 255), Imgproc.FILLED);
+                } else {
+                    cornerPoints.add(point);
+                    Imgproc.circle(dst, point, 4, new Scalar(0, 0, 0), Imgproc.FILLED);
+                }
+            }
+//            {139.0, 240.0} 左上 {144.0, 837.0} 左下
+//            {482.0, 238.0} 右上 {532.0, 825.0} 右下
+            Collections.sort(cornerPoints, new Comparator<Point>() {
+                @Override
+                public int compare(Point p1, Point p2) {
+                    return (int) (p1.x + p1.y - p2.x - p2.y);
+                }
+            });
             Imgcodecs.imwrite("D:\\data\\coners.jpg", dst);
+            for (Point p : cornerPoints) {
+                System.out.println(p.toString());
+            }
+            result.put("leftTop", cornerPoints.get(0));
+            result.put("rightBottom", cornerPoints.get(3));
+            if (cornerPoints.get(2).y > cornerPoints.get(1).y) {
+                result.put("rightTop", cornerPoints.get(1));
+                result.put("leftBottom", cornerPoints.get(2));
+            } else {
+                result.put("rightTop", cornerPoints.get(2));
+                result.put("leftBottom", cornerPoints.get(1));
+            }
+            ResultMapUtils.setResultMap(result, StatusCode.COMMON_SUCCESS);
+            System.out.println(result.toString());
+            return result;
         } catch (Exception e) {
             e.printStackTrace();
-            System.out.println("例外:" + e);
+            ResultMapUtils.setResultMap(result, StatusCode.COMMON_SERVER_ERROR);
+            return result;
         }
     }
 
-    /**
-     * OpenCV-4.1.0 Harris 角点检测
-     *
-     * @return void
-     * @Author: hyacinth
-     * @Title: harris
-     * @Description: TODO
-     * @date: 2019年8月26日 下午10:13:10
-     */
-    public static void harris() {
-        //载入图片
-        Mat src = Imgcodecs.imread("D:\\data\\167.jpg");
-        Mat gray = new Mat();
-        Mat dst = new Mat();
-        //灰度处理
-        Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);
-        HighGui.imshow("灰度处理", gray);
-        Imgproc.cornerHarris(gray, dst, 2, 3, 0.06);
-        HighGui.imshow("角点检测", dst);
-        Core.normalize(dst, dst, 0, 255, Core.NORM_MINMAX, -1, new Mat());
-        HighGui.imshow("归一处理", dst);
-        Core.convertScaleAbs(dst, dst);
-
-        Mat result = src.clone();
-        for (int i = 0, row = result.rows(); i < row; i++) {
-            for (int j = 0, col = result.cols(); j < col; j++) {
-                if (dst.get(i, j).clone()[0] > 180) {
-                    Imgproc.circle(result, new Point(j, i), 1, new Scalar(0, 0, 255), Imgproc.FILLED);
-                    System.out.println("像素点位:" + j + "," + i);
+    public static List<Point> matCornerList(List<Point> points) {
+        List<Point> matCornerList = new ArrayList<>();
+        matCornerList.add(points.get(0));
+        matCornerList.add(points.get(1));
+        matCornerList.add(points.get(3));
+        matCornerList.add(points.get(2));
+        return matCornerList;
+    }
+
+    public static List<Point> detectConerList() {
+        List<Point> result = new ArrayList<>();
+        try {
+            System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+            final int maxCorners = 50, blockSize = 3;
+            final double qualityLevel = 0.01, minDistance = 20.0, k = 0.04;
+            final boolean useHarrisDetector = false;
+            MatOfPoint corners = new MatOfPoint();
+
+            Mat src = Imgcodecs.imread("D:\\data\\167.jpg");
+            if (src.empty()) {
+                throw new Exception("no file");
+            }
+            Mat dst = src.clone();
+            Mat gray = new Mat();
+            Imgproc.cvtColor(src, gray, Imgproc.COLOR_RGB2GRAY);
+            Imgproc.goodFeaturesToTrack(gray, corners, maxCorners, qualityLevel, minDistance,
+                    new Mat(), blockSize, useHarrisDetector, k);
+            Point[] pCorners = corners.toArray();
+            List<Point> pointList = new ArrayList<>();
+            double maxX = 0d;
+            double maxY = 0d;
+            double minX = 10000d;
+            double minY = 100000d;
+            for (int i = 0; i < pCorners.length; i++) {
+                if (pCorners[i].x > 130 && pCorners[i].x < 570 && pCorners[i].y > 200 && pCorners[i].y < 850) {
+                    if (pCorners[i].x >= maxX) {
+                        maxX = pCorners[i].x;
+                    }
+                    if (pCorners[i].y >= maxY) {
+                        maxY = pCorners[i].y;
+                    }
+
+                    if (pCorners[i].x <= minX) {
+                        minX = pCorners[i].x;
+                    }
+
+                    if (pCorners[i].y <= minY) {
+                        minY = pCorners[i].y;
+                    }
+                    pointList.add(pCorners[i]);
                 }
             }
+            List<Point> cornerPoints = new ArrayList<>();
+            for (Point point : pointList) {
+                double getX = point.x;
+                double getY = point.y;
+                if ((getY >= (minY + 20) && getY <= (maxY - 20))) {
+                    Imgproc.circle(dst, point, 4, new Scalar(255, 255, 255), Imgproc.FILLED);
+                } else {
+                    cornerPoints.add(point);
+                    Imgproc.circle(dst, point, 4, new Scalar(0, 0, 255), Imgproc.FILLED);
+                }
+            }
+            Collections.sort(cornerPoints, new Comparator<Point>() {
+                @Override
+                public int compare(Point p1, Point p2) {
+                    return (int) (p1.x + p1.y - p2.x - p2.y);
+                }
+            });
+            //左上
+            result.add(new Point(cornerPoints.get(0).x - EXPAND_SIZE, cornerPoints.get(0).y - EXPAND_SIZE));
+            if (cornerPoints.get(2).y > cornerPoints.get(1).y) {
+                //右上
+                result.add(new Point(cornerPoints.get(1).x + EXPAND_SIZE, cornerPoints.get(1).y - EXPAND_SIZE));
+                //左下
+                result.add(new Point(cornerPoints.get(2).x - EXPAND_SIZE, cornerPoints.get(2).y + EXPAND_SIZE));
+            } else {
+                //右上
+                result.add(new Point(cornerPoints.get(2).x + EXPAND_SIZE, cornerPoints.get(2).y - EXPAND_SIZE));
+                //左下
+                result.add(new Point(cornerPoints.get(1).x - EXPAND_SIZE, cornerPoints.get(1).y + EXPAND_SIZE));
+            }
+            //右下
+            result.add(new Point(cornerPoints.get(3).x + EXPAND_SIZE, cornerPoints.get(3).y + EXPAND_SIZE));
+            return result;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return result;
         }
-
-        HighGui.imshow("Harris 角点检测", result);
-        HighGui.waitKey(0);
     }
 }

+ 182 - 47
jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/opencv/Perspective.java

@@ -1,10 +1,7 @@
 package org.jeecg.modules.demo.opencv;
 
 
-import org.opencv.core.Core;
-import org.opencv.core.CvType;
-import org.opencv.core.Mat;
-import org.opencv.core.Point;
+import org.opencv.core.*;
 import org.opencv.imgcodecs.Imgcodecs;
 import org.opencv.imgproc.Imgproc;
 import org.opencv.utils.Converters;
@@ -16,62 +13,200 @@ import java.util.List;
  */
 public class Perspective {
     public static void main(String[] args) {
+
+    }
+
+    public static void perpectiveImg(String backgroundImgPath, String phoneImgPath, String targetFileName) {
         try {
             System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
 
-            Mat src = Imgcodecs.imread("d://data//123.jpg");
-            Mat test = Imgcodecs.imread("d://data//test.jpg");
+            Mat src = Imgcodecs.imread(phoneImgPath);
+            Mat dst = Imgcodecs.imread(backgroundImgPath);
+            Mat dst1 = dst.clone();
+            //透视变换点位
+            List<Point> perspectivePoints = CornerCheck.detectConerList();
+            //矩形点位
+            List<Point> matPoints = CornerCheck.matCornerList(perspectivePoints);
             //读取图像到矩阵中
             if (src.empty()) {
                 throw new Exception("no file");
             }
 
-            int xMargin, yMargin;
-            int x0 = src.cols() / 4;
-            int x1 = (src.cols() / 4) * 3;
-            int y0 = src.cols() / 4;
-            int y1 = (src.cols() / 4) * 3;
-            Mat dst = new Mat();
-
-            List<Point> listSrcs = java.util.Arrays.asList(new Point(x0, y0), new Point(x0, y1), new Point(x1, y1), new Point(x1, y0));
+            List<Point> listSrcs = java.util.Arrays.asList(new Point(0, 0), new Point(src.cols(), 0), new Point(0, src.rows()), new Point(src.cols(), src.rows()));
             Mat srcPoints = Converters.vector_Point_to_Mat(listSrcs, CvType.CV_32F);
-
-            xMargin = src.cols() / 10;
-            yMargin = src.rows() / 10;
-            List<Point> listDsts = java.util.Arrays.asList(new Point(x0 + xMargin, y0 + yMargin), listSrcs.get(1), listSrcs.get(2), new Point(x1 - xMargin, y0 + yMargin));
-            Mat dstPoints = Converters.vector_Point_to_Mat(listDsts, CvType.CV_32F);
-
+            Mat dstPoints = Converters.vector_Point_to_Mat(perspectivePoints, CvType.CV_32F);
             Mat perspectiveMmat = Imgproc.getPerspectiveTransform(srcPoints, dstPoints);
-            Imgproc.warpPerspective(src, dst, perspectiveMmat, src.size(), Imgproc.INTER_LINEAR);
-            Imgcodecs.imwrite("d://data//1.jpg", dst);
-
-            xMargin = src.cols() / 8;
-            yMargin = src.cols() / 8;
-            listDsts.set(0, listSrcs.get(0));
-            listDsts.set(1, listSrcs.get(1));
-            listDsts.set(2, new Point(x1 - xMargin, y1 - yMargin));
-            listDsts.set(3, new Point(x1 - xMargin, y0 - yMargin));
-            dstPoints = Converters.vector_Point_to_Mat(listDsts, CvType.CV_32F);
-
-            perspectiveMmat = Imgproc.getPerspectiveTransform(srcPoints, dstPoints);
-            Imgproc.warpPerspective(src, dst, perspectiveMmat, src.size(), Imgproc.INTER_LINEAR);
-            Imgcodecs.imwrite("d://data//2.jpg", dst);
-
-            xMargin = src.cols() / 6;
-            yMargin = src.cols() / 6;
-            listDsts.set(0, new Point(x0 + xMargin, y0 + yMargin));
-            listDsts.set(1, listSrcs.get(1));
-            listDsts.set(2, new Point(x1 - xMargin, y1 - yMargin));
-            listDsts.set(3, listSrcs.get(3));
-            dstPoints = Converters.vector_Point_to_Mat(listDsts, CvType.CV_32F);
-
-            perspectiveMmat = Imgproc.getPerspectiveTransform(srcPoints, dstPoints);
-            Imgproc.warpPerspective(src, dst, perspectiveMmat, src.size(), Imgproc.INTER_LINEAR);
-
-            Imgcodecs.imwrite("d://data//3.jpg", dst);
+            Imgproc.warpPerspective(src, dst, perspectiveMmat, dst.size(), Imgproc.INTER_LINEAR);
+            System.out.println("cols:" + dst1.cols());
+            System.out.println("rows:" + dst1.rows());
+            for (int i = 0; i < dst1.cols(); i++) {
+                for (int j = 0; j < dst1.rows(); j++) {
+                    Point point = new Point();
+                    point.x = i;
+                    point.y = j;
+                    if (isPtInPoly(point, matPoints)) {
+                        Imgproc.circle(dst1, point, 8, new Scalar(0, 0, 0), Imgproc.FILLED);
+                    }
+                }
+            }
+            Core.addWeighted(dst1, 1, dst, 1, 3, dst);
+            Imgcodecs.imwrite(targetFileName, dst);
         } catch (Exception e) {
+            e.printStackTrace();
             System.out.println("例外:" + e);
         }
+    }
+
+    public static boolean isInner(Point point, List<Point> corners) {
+        int n = corners.size(); //n=4
+        double sum = 0;
+        for (int i = 0; i < n - 1; i++) {
+            sum += area(corners.get(i), corners.get(i + 1), point);
+        }
+        sum += area(corners.get(n - 1), corners.get(0), point);
+
+        double polyArea = area(corners.get(0), corners.get(1), corners.get(2)) + area(corners.get(1), corners.get(2), corners.get(3));
+        if (sum == polyArea) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    //已知坐标,求三角形面积
+    private static double area(Point p1, Point p2, Point p3) {
+        return 0.5 * Math.abs((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y));
+    }
+
+    public static boolean isPtInPolygon(Point point, List<Point> polygon) {
+        int iSum, iIndex;
+        double dLon1, dLon2, dLat1, dLat2, dLon;
+        int size = polygon.size();
+        iSum = 0;
+        for (iIndex = 0; iIndex < size; iIndex++) {
+            if (iIndex == size - 1) {
+                dLon1 = polygon.get(iIndex).x;
+                dLat1 = polygon.get(iIndex).y;
+                dLon2 = polygon.get(0).x;
+                dLat2 = polygon.get(0).y;
+            } else {
+                dLon1 = polygon.get(iIndex).x;
+                dLat1 = polygon.get(iIndex).y;
+                dLon2 = polygon.get(iIndex + 1).x;
+                dLat2 = polygon.get(iIndex + 1).y;
+            }
+            // 以下语句判断A点是否在边的两端点的水平平行线之间,在则可能有交点,开始判断交点是否在左射线上
+            if (((point.y >= dLat1) && (point.y < dLat2))
+                    || ((point.y >= dLat2) && (point.y < dLat1))) {
+                if (Math.abs(dLat1 - dLat2) > 0) {
+                    //得到 A点向左射线与边的交点的x坐标:
+                    dLon = dLon1 - ((dLon1 - dLon2) * (dLat1 - point.y)) / (dLat1 - dLat2);
+                    // 如果交点在A点左侧(说明是做射线与 边的交点),则射线与边的全部交点数加一:
+                    if (dLon < point.x) {
+                        iSum++;
+                    }
+                }
+            }
+        }
+        return (iSum % 2) != 0;
+    }
+
+    /**
+     * 判断点是否在多边形内,如果点位于多边形的顶点或边上,也算做点在多边形内,直接返回true
+     *
+     * @param point   检测点
+     * @param polygon 多边形的顶点
+     * @return 点在多边形内返回true, 否则返回false
+     */
+    public static boolean isPtInPoly(Point point, List<Point> polygon) {
+
+        int N = polygon.size();
+        //如果点位于多边形的顶点或边上,也算做点在多边形内,直接返回true
+        boolean boundOrVertex = true;
+        //cross points count of x
+        int intersectCount = 0;
+        //浮点类型计算时候与0比较时候的容差
+        double precision = 2e-10;
+        //neighbour bound vertices
+        Point p1, p2;
+        //当前点
+        Point p = point;
+
+        //left vertex
+        p1 = polygon.get(0);
+        //check all rays
+        for (int i = 1; i <= N; ++i) {
+            if (p.equals(p1)) {
+                //p is an vertex
+                return boundOrVertex;
+            }
+
+            //right vertex
+            p2 = polygon.get(i % N);
+            //ray is outside of our interests
+            if (p.x < Math.min(p1.x, p2.x) || p.x > Math.max(p1.x, p2.x)) {
+                p1 = p2;
+                //next ray left point
+                continue;
+            }
+
+            //ray is crossing over by the algorithm (common part of)
+            if (p.x > Math.min(p1.x, p2.x) && p.x < Math.max(p1.x, p2.x)) {
+                //x is before of ray
+                if (p.y <= Math.max(p1.y, p2.y)) {
+                    //overlies on a horizontal ray
+                    if (p1.x == p2.x && p.y >= Math.min(p1.y, p2.y)) {
+                        return boundOrVertex;
+                    }
+
+                    //ray is vertical
+                    if (p1.y == p2.y) {
+                        //overlies on a vertical ray
+                        if (p1.y == p.y) {
+                            return boundOrVertex;
+                            //before ray
+                        } else {
+                            ++intersectCount;
+                        }
+                        //cross point on the left side
+                    } else {
+                        //cross point of y
+                        double xinters = (p.x - p1.x) * (p2.y - p1.y) / (p2.x - p1.x) + p1.y;
+                        //overlies on a ray
+                        if (Math.abs(p.y - xinters) < precision) {
+                            return boundOrVertex;
+                        }
+
+                        //before ray
+                        if (p.y < xinters) {
+                            ++intersectCount;
+                        }
+                    }
+                }
+                //special case when ray is crossing through the vertex
+            } else {
+                //p crossing over p2
+                if (p.x == p2.x && p.y <= p2.y) {
+                    //next vertex
+                    Point p3 = polygon.get((i + 1) % N);
+                    //p.x lies between p1.x & p3.x
+                    if (p.x >= Math.min(p1.x, p3.x) && p.x <= Math.max(p1.x, p3.x)) {
+                        ++intersectCount;
+                    } else {
+                        intersectCount += 2;
+                    }
+                }
+            }
+            //next ray left point
+            p1 = p2;
+        }
 
+        //偶数在多边形外
+        if (intersectCount % 2 == 0) {
+            return false;
+            //奇数在多边形内
+        } else {
+            return true;
+        }
     }
 }

+ 15 - 0
jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/opencv/Test.java

@@ -0,0 +1,15 @@
+package org.jeecg.modules.demo.opencv;
+
+public class Test {
+    public static void main(String[] args) {
+        String srcPath = "D://data//images/";
+        String targetPath = "D://data//video/";
+        for (int i = 163; i <= 235; i++) {
+            String backImg = srcPath + (i) + ".jpg";
+            String phoneImg = srcPath + (i - 163) + ".jpg";
+            String targetImg = targetPath + i + ".jpg";
+            Perspective.perpectiveImg(backImg, phoneImg, targetImg);
+        }
+    }
+
+}

+ 15 - 31
jeecg-boot-module-system/src/test/java/org/jeecg/SampleTest.java

@@ -1,8 +1,11 @@
 package org.jeecg;
 
+import cn.com.ctop.bytedance.service.IReportService;
 import cn.com.ctop.common.module.entity.CtopOauthToken;
+import cn.com.ctop.common.module.entity.UserAllocation;
 import cn.com.ctop.common.module.mapper.CtopOauthTokenMapper;
 import cn.com.ctop.common.module.service.ICtopOauthTokenService;
+import cn.com.ctop.common.module.service.IUserAllocationService;
 import cn.com.ctop.common.module.utils.CtopAdConstant;
 import cn.com.ctop.kuaishou.modules.batch.service.IKuaiShouHistoryReportTaskService;
 import cn.com.ctop.kuaishou.modules.batch.service.IKuaishouInterfaceService;
@@ -129,40 +132,21 @@ public class SampleTest {
 
     @Test
     public void testLoadJob() {
-        log.info("快手获取日报数据任务执行开始");
-        Long start = System.currentTimeMillis();
         Date getDate = DateUtils.addDay(new Date(), -1);
-        List<CtopOauthToken> tokens = tokenService.getTokenListByType(CtopAdConstant.PLATFORM_TYPE_KUAISHOU);
-        if (null == tokens || tokens.size() <= 0) {
-            log.info("快手获取日报数据任务执行失败:未获取到可用的token");
-            return;
-        }
-        String getDateStr = DateUtils.formatDate(getDate);
-        countDownLatch = new CountDownLatch(tokens.size());
-        for (CtopOauthToken token : tokens) {
-            executorService.submit(new Runnable() {
-                @Override
-                public void run() {
-                    //创建任务
-                    try {
-                        reportTaskService.createTask(token.getAccountId(), token.getAccessToken(), getDateStr, getDateStr, CtopAdConstant.KUAISHOU_LOAD_JOB_TYPE_DAILY);
-                    } catch (Exception e) {
-                        e.printStackTrace();
-                    } finally {
-                        countDownLatch.countDown();
-                    }
-                }
-            });
-        }
-        try {
-            countDownLatch.await();
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
-        Long end = System.currentTimeMillis();
-        log.info("快手获取日报数据任务执行结束,执行耗时:{}秒", (end - start) / 1000);
+        //1:查询当日数据
+        QueryWrapper<UserAllocation> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("project_id", 222);
+        List<UserAllocation> allocations = userAllocationService.list(queryWrapper);
+        allocations.forEach(allocation -> {
+            CtopOauthToken token = tokenService.getTokenByAccountId(allocation.getAccountId());
+            reportService.getAdvertiserPlanReport(token, getDate, getDate, CtopAdConstant.BYTEDANCE_REPORT_TYPE_HOURLY);
+        });
     }
 
+    @Autowired
+    private IReportService reportService;
+    @Autowired
+    private IUserAllocationService userAllocationService;
 
 }
 

+ 1 - 0
module-report/src/main/java/cn/com/ctop/bytedance/service/impl/ReportServiceImpl.java

@@ -84,6 +84,7 @@ public class ReportServiceImpl implements IReportService {
         config.propertyNamingStrategy = PropertyNamingStrategy.SnakeCase;
         JSONObject jsonObject = JSONObject.parseObject(JSON.toJSONString(conditions, config));
         JSONObject getObject = getAdvertiserStat(token, jsonObject);
+        System.out.println(getObject.toJSONString());
         Integer code = getObject.getInteger("code");
         String message = getObject.getString("message");
         if (null == code || code != 0) {