获得图片色调工具类

-

-

ColorThiefUtils.java

-

-

/*
 * Copyright (C) 2015 Henrique Rocha
 * Copyright (C) 2014 Fonpit AG
 *
 * License
 * -------
 * Creative Commons Attribution 2.5 License:
 * http://creativecommons.org/licenses/by/2.5/
 *
 * Thanks
 * ------
 * Simon Oualid - For creating java-colorthief
 * available at https://github.com/soualid/java-colorthief
 *
 * Lokesh Dhakar - for the original Color Thief javascript version
 * available at http://lokeshdhakar.com/projects/color-thief/
 *
 */

package com.library.util;

import android.graphics.Bitmap;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 获得图片色调工具类
 * Created by zsw on 2016/7/4.
 */
public class ColorThiefUtils {

    private static final int SIGBITS = 5;
    private static final int RSHIFT = 8 - SIGBITS;
    private static final int MAX_ITERATIONS = 1000;
    private static final double FRACT_BY_POPULATION = 0.75;

    private static final int RED = 0;
    private static final int GREEN = 1;
    private static final int BLUE = 2;

    public static List<int[]> compute(Bitmap image, int maxcolors) throws IOException {
        List<int[]> pixels = getPixels(image);
        return compute(pixels, maxcolors);
    }

    public static List<int[]> compute(List<int[]> pixels, int maxcolors) {
        ColorMap map = quantize(pixels, maxcolors);
        return map.palette();
    }

    private static List<int[]> getPixels(Bitmap image) {
        int width = image.getWidth();
        int height = image.getHeight();
        List<int[]> res = new ArrayList<>();
        List<Integer> t = new ArrayList<>();
        for (int row = 0; row < height; row++) {
            for (int col = 0; col < width; col++) {
                if(!image.isRecycled())
                    t.add(image.getPixel(col, row));
            }
        }
        for (int i = 0; i < t.size(); i += 10) {
            int[] rr = new int[3];
            int argb = t.get(i);
            rr[0] = (argb >> 16) & 0xFF;
            rr[1] = (argb >> 8) & 0xFF;
            rr[2] = (argb) & 0xFF;
            if (!(rr[0] > 250 && rr[1] > 250 && rr[2] > 250)) {
                res.add(rr);
            }
        }
        return res;
    }

    private static int getColorIndex(int r, int g, int b) {
        return (r << (2 * SIGBITS)) + (g << SIGBITS) + b;
    }

    private static int[] histogram(List<int[]> pixels) {
        int[] histogram = new int[1 << (3 * SIGBITS)];

        for (int[] pixel : pixels) {
            int rval = pixel[0] >> RSHIFT;
            int gval = pixel[1] >> RSHIFT;
            int bval = pixel[2] >> RSHIFT;
            histogram[getColorIndex(rval, gval, bval)]++;
        }

        return histogram;
    }

    private static VBox vboxFromPixels(List<int[]> pixels, int[] histo) {
        int rmin = 1000000, rmax = 0, gmin = 1000000, gmax = 0, bmin = 1000000, bmax = 0, rval, gval, bval;
        for (int[] pixel : pixels) {
            rval = pixel[0] >> RSHIFT;
            gval = pixel[1] >> RSHIFT;
            bval = pixel[2] >> RSHIFT;
            if (rval < rmin)
                rmin = rval;
            else if (rval > rmax)
                rmax = rval;
            if (gval < gmin)
                gmin = gval;
            else if (gval > gmax)
                gmax = gval;
            if (bval < bmin)
                bmin = bval;
            else if (bval > bmax)
                bmax = bval;
        }
        return new VBox(rmin, rmax, gmin, gmax, bmin, bmax, histo);
    }

    private static VBox[] medianCutApply(int[] histo, VBox vbox) {
        if (vbox.count(false) == 0)
            return null;
        if (vbox.count(false) == 1) {
            return new VBox[]{vbox.copy()};
        }
        int rw = vbox.r2 - vbox.r1 + 1, gw = vbox.g2 - vbox.g1 + 1, bw = vbox.b2 - vbox.b1 + 1, maxw = Math.max(Math.max(rw, gw), bw);

        int total = 0;
        List<Integer> partialsum = new ArrayList<>();
        List<Integer> lookaheadsum = new ArrayList<>();

        if (maxw == rw) {
            for (int i = vbox.r1; i <= vbox.r2; i++) {
                int sum = 0;
                for (int j = vbox.g1; j <= vbox.g2; j++) {
                    for (int k = vbox.b1; k <= vbox.b2; k++) {
                        sum += histo[getColorIndex(i, j, k)];
                    }
                }
                total += sum;
                if (partialsum.size() < i) {
                    int toAdd = i - partialsum.size();
                    for (int l = partialsum.size(); l < toAdd; l++) {
                        partialsum.add(0);
                    }
                }
                partialsum.add(i, total);
            }
        } else if (maxw == gw) {
            for (int i = vbox.g1; i <= vbox.g2; i++) {
                int sum = 0;
                for (int j = vbox.r1; j <= vbox.r2; j++) {
                    for (int k = vbox.b1; k <= vbox.b2; k++) {
                        sum += histo[getColorIndex(j, i, k)];
                    }
                }
                total += sum;
                if (partialsum.size() < i) {
                    int toAdd = i - partialsum.size();
                    for (int l = partialsum.size(); l < toAdd; l++) {
                        partialsum.add(0);
                    }
                }
                partialsum.add(i, total);
            }
        } else {
            for (int i = vbox.b1; i <= vbox.b2; i++) {
                int sum = 0;
                for (int j = vbox.r1; j <= vbox.r2; j++) {
                    for (int k = vbox.g1; k <= vbox.g2; k++) {
                        sum += histo[getColorIndex(j, k, i)];
                    }
                }
                total += sum;
                if (partialsum.size() < i) {
                    int toAdd = i - partialsum.size();
                    for (int l = partialsum.size(); l < toAdd; l++) {
                        partialsum.add(0);
                    }
                }
                partialsum.add(i, total);
            }
        }

        for (int i = 0; i < partialsum.size(); i++) {
            lookaheadsum.add(i, total - partialsum.get(i));
        }

        return maxw == rw
                ? doCut(RED, vbox, partialsum, lookaheadsum, total)
                : maxw == gw
                ? doCut(GREEN, vbox, partialsum, lookaheadsum, total)
                : doCut(BLUE, vbox, partialsum, lookaheadsum, total);
    }

    private static VBox[] doCut(int color, VBox vbox, List<Integer> partialsum, List<Integer> lookaheadsum, int total) {
        int dim1 = 0, dim2 = 0;
        if (color == RED) {
            dim1 = vbox.getR1();
            dim2 = vbox.getR2();
        } else if (color == GREEN) {
            dim1 = vbox.getG1();
            dim2 = vbox.getG2();
        } else if (color == BLUE) {
            dim1 = vbox.getB1();
            dim2 = vbox.getB2();
        }
        VBox vbox1, vbox2;
        int left, right, d2;
        Integer count2;
        for (int i = dim1; i < dim2; i++) {
            if (partialsum.get(i) > total / 2) {
                vbox1 = vbox.copy();
                vbox2 = vbox.copy();
                left = i - dim1;
                right = dim2 - i;
                if (left <= right) {
                    d2 = Math.min(dim2 - 1, ~~(i + right / 2));
                } else {
                    d2 = Math.max(dim1, ~~(i - 1 - left / 2));
                }
                while (partialsum.get(d2) == null)
                    d2++;
                count2 = lookaheadsum.get(d2);
                while (count2 == null && partialsum.get(d2 - 1) == null)
                    count2 = lookaheadsum.get(--d2);
                if (color == RED) {
                    vbox1.setR2(d2);
                    vbox2.setR1(vbox1.getR2() + 1);
                } else if (color == GREEN) {
                    vbox1.setG2(d2);
                    vbox2.setG1(vbox1.getG2() + 1);
                } else if (color == BLUE) {
                    vbox1.setB2(d2);
                    vbox2.setB1(vbox1.getB2() + 1);
                }
                return new VBox[]{vbox1, vbox2};
            }
        }
        return null;
    }

    @SuppressWarnings("unchecked")
    private static ColorMap quantize(List<int[]> pixels, int maxcolors) {
        if (pixels.size() == 0 || maxcolors < 2 || maxcolors > 256) {
            return null;
        }
        int[] histo = histogram(pixels);
        int nColors = 0;
        VBox vbox = vboxFromPixels(pixels, histo);
        List<VBox> pq = new ArrayList<>();
        pq.add(vbox);
        int niters = 0;
        Object[] r = iter(pq, FRACT_BY_POPULATION * maxcolors, histo, nColors, niters);
        pq = (List<VBox>) r[0];
        nColors = (Integer) r[1];
        niters = (Integer) r[2];
        Collections.sort(pq);
        r = iter(pq, maxcolors - pq.size(), histo, nColors, niters);
        pq = (List<VBox>) r[0];
        ColorMap cmap = new ColorMap();
        for (VBox vBox2 : pq) {
            cmap.push(vBox2);
        }
        return cmap;
    }

    private static Object[] iter(List<VBox> lh, double target, int[] histo, int nColors, int niters) {
        VBox vbox;
        while (niters < MAX_ITERATIONS) {
            vbox = lh.get(lh.size() - 1);
            lh.remove(lh.size() - 1);
            if (vbox.count(false) == 0) {
                lh.add(vbox);
                niters++;
                continue;
            }
            VBox[] vboxes = medianCutApply(histo, vbox);

            VBox vbox1 = vboxes[0];
            VBox vbox2 = vboxes[1];

            if (vbox1 == null)
                return new Object[]{lh, nColors, niters};
            lh.add(vbox1);
            if (vbox2 != null) {
                lh.add(vbox2);
                nColors++;
            }
            if (nColors >= target)
                return new Object[]{lh, nColors, niters};
            if (niters++ > MAX_ITERATIONS) {
                return new Object[]{lh, nColors, niters};
            }
            Collections.sort(lh);
        }
        return new Object[]{lh, nColors, niters};
    }

    static class VBox implements Comparable {
        private int r1;
        private int r2;
        private int g1;
        private int g2;
        private int b1;
        private int b2;
        private int[] avg;
        private Integer volume;
        private Integer count;
        private int[] histo;

        // r1: 0 / r2: 18 / g1: 0 / g2: 31 / b1: 0 / b2: 31
        public VBox(int r1, int r2, int g1, int g2, int b1, int b2, int[] histo) {
            super();
            this.r1 = r1;
            this.r2 = r2;
            this.g1 = g1;
            this.g2 = g2;
            this.b1 = b1;
            this.b2 = b2;
            this.histo = histo;
        }

        @Override
        public String toString() {
            return "r1: " + r1 + " / r2: " + r2 + " / g1: " + g1 + " / g2: " + g2 + " / b1: " + b1 + " / b2: " + b2 + "\n";
        }

        public int getVolume(boolean recompute) {
            if (volume == null || recompute) {
                volume = ((r2 - r1 + 1) * (g2 - g1 + 1) * (b2 - b1 + 1));
            }
            return volume;
        }

        public VBox copy() {
            return new VBox(r1, r2, g1, g2, b1, b2, histo);
        }

        public int[] avg(boolean recompute) {
            if (avg != null && !recompute) return avg;

            int ntot = 0;
            int mult = 1 << (8 - SIGBITS);
            int redSum = 0, greenSum = 0, blueSum = 0;
            int hval;

            for (int i = r1; i <= r2; i++) {
                for (int j = g1; j <= g2; j++) {
                    for (int k = b1; k <= b2; k++) {
                        hval = histo[getColorIndex(i, j, k)];
                        ntot += hval;
                        redSum += (hval * (i + 0.5) * mult);
                        greenSum += (hval * (j + 0.5) * mult);
                        blueSum += (hval * (k + 0.5) * mult);
                    }
                }
            }

            if (ntot > 0) {
                avg = new int[]{~~(redSum / ntot), ~~(greenSum / ntot), ~~(blueSum / ntot)};
            } else {
                avg = new int[]{~~(mult * (r1 + r2 + 1) / 2), ~~(mult * (g1 + g2 + 1) / 2), ~~(mult * (b1 + b2 + 1) / 2)};
            }

            return avg;
        }

        public int count(boolean recompute) {
            if (count != null && !recompute) return count;

            int npix = 0;
            for (int i = r1; i <= r2; i++) {
                for (int j = g1; j <= g2; j++) {
                    for (int k = b1; k <= b2; k++) {
                        int index = getColorIndex(i, j, k);
                        int g = histo[index];
                        npix += g;
                    }
                }
            }
            count = npix;

            return count;
        }

        public int getR1() {
            return r1;
        }

        public void setR1(int r1) {
            this.r1 = r1;
        }

        public int getR2() {
            return r2;
        }

        public void setR2(int r2) {
            this.r2 = r2;
        }

        public int getG1() {
            return g1;
        }

        public void setG1(int g1) {
            this.g1 = g1;
        }

        public int getG2() {
            return g2;
        }

        public void setG2(int g2) {
            this.g2 = g2;
        }

        public int getB1() {
            return b1;
        }

        public void setB1(int b1) {
            this.b1 = b1;
        }

        public int getB2() {
            return b2;
        }

        public void setB2(int b2) {
            this.b2 = b2;
        }

        @Override
        public int compareTo(Object o) {
            VBox anotherVBox = (VBox) o;
            return count(false) * getVolume(false) - anotherVBox.count(false) * anotherVBox.getVolume(false);
        }
    }

    static class ColorMap {
        private ArrayList<int[]> vboxes = new ArrayList<>();

        public void push(VBox box) {
            vboxes.add(0, box.avg(false));
        }

        public List<int[]> palette() {
            return vboxes;
        }

    }

}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第1章 Java概述、安装及简易教学 14 1-1 Java概述 14 1-2 Java安装 16 1-3 Eclipse安装 18 1-4 GUI设计工具WindowBuilder 18 1-5 在Eclipse开发第一个Java程式 23 1-6 在Eclipse开发第一个Java视窗程式-显示影像 26 1-7 在Eclipse开发视窗程式-slider控制元件 34 1-8 在Eclipse开发视窗程式-按钮控制元件 39 1-9 好用的Eclipse热键 41 第2章 OpenCV概述、安装及设定 42 2-2 关于OpenCV 3.0及3.1 43 2-3 使用Java开发OpenCV的缺点 45 2-4 OpenCV的下载及安装 45 2-5 Eclipse设定OpenCV开发环境 46 2-6 整合Java之Eclipse与OpenCV 49 2-7 开发第一个OpenCV程式 51 2-8 建立矩阵 52 范例2-8-1 建立第一个opencv的矩阵,使用阵列 53 范例2-8-2 建立opencv的Mat矩阵方法2 55 范例2-8-3 方法3以单一元素指定 56 范例2-8-4 方法4全部以同一元素指定 57 范例2-8-5 方法5以个别单一元素指定 58 范例2-8-6 方法6以1维阵列指定建立 59 第3章 OpenCV基础数学计算 60 范例3-1-1 矩阵的线性代数计算1 60 范例3-1-2 矩阵的矩阵线性代数计算2-加减乘除处理 62 范例3-1-3 矩阵的矩阵线性代数计算3 65 范例3-2-1 矩阵的统计方面计算1 68 范例3-2-2矩阵的统计方面计算2 69 范例3-3-1 矩阵其他数学计算 72 第4章 影像基本输出输入处理 78 范例4-1-1 Opencv读取写入练习 79 范例4-1-2 Opencv读取影像并显示至视窗 81 范例4-1-3 Opencv读取影像显示至视窗-版本2 84 范例4-1-4影像储存压缩品质选择 87 范例4-2-1 Opencv使用webcam拍照,并存放置资料匣 89 范例4-2-2 使用webcam拍照明亮版-并存放影像在资料匣 90 范例4-2-3 使用webcam读取动态影像至Java Swing视窗 91 范例4-2-4 使用webcam读取动态影像至Java Swing视窗2 92 范例4-2-5 手动拍照 94 范例4-2-6 使用webcam录制影片档 96 范例4-2-7 使用xuggle录制电脑画面 99 范例4-2-8 使用Opencv API录制影片档案 102 范例4-3-1 Opencv API拨放影片档案,使用Panel 104 范例4-3-2 Opencv API拨放影片档案,不使用Panel 105 范例4-4-1从IPCam读取网路串流影像 107 范例4-4-2从IPCam拍摄照片 108 第5章 影像基本处理 109 范例5-1-1使用ConvertTo调整影像明亮度 109 范例5-1-2使用ConvertTo及GUI元件调整影像明暗度 110 范例5-1-3使用addWeighted及GUI元件调整影像明亮度 111 范例5-1-4改变影像的每1个像素调整影像明亮度 112 范例5-2-1全彩图转灰阶图 113 范例5-3-1影像颜色相反,使用Bitwise_xor 114 范例5-3-2影像颜色相反,使用subtract 115 范例5-3-3影像颜色相反,使用Bitwise_not 116 范例5-4-1模糊处理-使用Gaussian高斯函数及GUI元件 116 范例5-4-2修正5-4-1高斯模糊的异常 117 范例5-4-3模糊处理-使用median函数及GUI元件 118 范例5-4-4模糊处理-使用BoxFilter函数及GUI元件 119 范例5-5-1 Threshold-使用临界值函数及GUI元件 122 范例5-5-2 AdaptiveThreshold-使用自适临界值及GUI元件 128 范例5-6-1 Sharpness锐利化处理 130 范例5-6-2锐利化处理,使用GUI元件 131 范例5-7-1 影像合并/融合处理处理,使用GUI元件 131 范例5-8-1 影像缩放-使用Gaussian高斯金字塔及GUI元件 133 范例5-8-2影像缩放-使用resize使用GUI元件 135 范例5-8-3 影像延展效果-使用resize使用GUI元件 136 范例5-8-4影像缩放-使用getRotationMatrix2D及GUI元件 137 范例5-9-1影像旋转以90度*n为主-使用remap及 GUI元件 138 范例5-9-2影像旋转以90度*n为主-使用Flip及 GUI元件 140 范例5-9-3 影像可任意角度旋转缩放使用 GUI元件 141 范例5-10-1 影像扭曲倾斜处理使用GUI元件 143 范例5-11-1 灰阶影像对比强化处理并GUI显示 147 范例5-11-2 影像强化对比效果,使用均衡化直方图 149 范例5-11-3 RGB彩色强化对比效果,使用均衡化直方图及融合 150 范例5-11-4 YUV彩色强化对比效果,使用均衡化直方图及融合 151 范例5-12-1 影像梦幻沙龙处理使用GUI显示 152 范例5-13-1 影像各式颜色空间转换于GUI显示 154 范例5-14-1 影像堆叠 155 范例5-15-1 影像马赛克处理 157 范例5-16-1 影像添加外框 158 范例5-17-1合并两个影像 160 范例5-17-2合并两个影像,使用不规则形状 161 第6章 使用核矩阵进行影像处理 165 范例6-1-1 Mean filter处理 165 范例6-2-1 Prewitt Filter处理 167 范例6-3-1 Laplacian Filter处理1 170 范例6-3-2 Laplacian Filter处理2 171 范例6-3-3 Laplacian Filter灰阶影像处理 173 范例6-3-4 Laplacian Filter使用核矩阵 173 范例6-4-1 Sobel Filter使用核矩阵 175 范例6-4-2 Sobel Filter处理使用内建API 176 范例6-4-3 Sobel Filter处理使用内建API2 178 范例6-5-1 Frei Chenn Filter处理 180 范例6-6-1 Scharr Filter使用核矩阵 180 范例6-6-2 Scharr使用API 181 范例6-7-1 Robinson Filter处理 182 范例6-8-1 Kirsch Filter处理 184 范例6-9-1 Emboss浮雕处理 186 范例6-10-1 创造自己的filter 187 范例6-11-1 SqrBoxFilter处理 188 第7章 绘图 190 范例7-1-1 画线 190 范例7-2-1 画点 191 范例7-3-1 画圆 191 范例7-4-1 画椭圆形 192 范例7-4-2 椭圆内近似多边形练习 194 范例7-5-1 填补凸多边形练习 195 范例7-6-1 多边形绘图(填满)练习 196 范例7-6-2 多边形填充使用滑鼠练习 197 范例7-7-1中空多边形绘图练习 198 范例7-8-1 输入文字练习 200 范例7-8-2 输入文字使用中文练习 202 范例7-8-3浮水印练习 205 范例7-9-1 矩形练习 206 范例7-9-2 判断A矩形是否有在B矩形内 207 范例7-10-1 综合应用:直方图统计练习 208 范例7-11-1 颜色洪水填充处理练习1 211 范例7-11-2 颜色洪水填充处理练习2 213 范例7-11-3 颜色洪水填充处理3-重拾小朋友填色乐趣. 214 范例7-12-1 综合练习:使用一个最小矩形包含一堆点 215 范例7-13-1 综合练习:使用一个最小矩形包含一堆矩形 216 范例7-14-1 综合练习:使用一个矩形撷取影像区块 218 范例7-14-2综合练习:中空多边形绘制使用滑鼠 220 范例7-14-3综合练习:使用多边形撷取不规则影像区块1 222 范例7-14-4 综合练习:使用多边形撷取不规则影像区块2 227 范例7-14-5 综合练习:使用多边形撷取影像贴至另一影像 228 范例7-15-1箭头练习 232 范例7-16-1 特殊符号练习 233 范例7-17-1 立体浮雕制作 235 第8章 进阶影像处理 241 范例8-1-1 Erosion腐蚀处理练习 241 范例8-2-1 Dilation膨胀处理练习 242 范例8-3-1 其他形态学变换处理练习 244 范例8-4-1 Canny边缘检测处理练习1 246 范例8-4-2 Canny边缘检测处理练习2 248 范例8-5-1 卡通化处理1,整合模糊及Canny 249 范例8-5-2 卡通化处理2 252 范例8-5-3 卡通化及线条Live版 253 范例8-6-1 抠出背景处理练习 254 范例8-7-1聚光灯效果处理练习 256 范例8-9-1 分水岭演算法Watershed处理练习 258 范例8-10-1 油画效果处理练习 261 范例8-11-1 多种色调处理练习 262 范例8-12-1 圆形转矩形处理练习 266 范例8-13-1 LogPolar极座标转换处理 267 第9章 强大相片类处理 270 范例9-1-1 影像修复功能处理练习 270 范例9-2-1 影像减色/脱色/降灰阶处理练习 272 范例9-3-1 消除杂点练习1 273 范例9-3-2 消除杂点练习2 274 范例9-3-3 消除杂点练习3 275 范例9-3-4 消除杂点练习4 276 范例9-4-1 HDR高动态范围成像练习 277 范例9-5-1 Seamless Cloning系列 Color Change练习 285 范例9-6-1 Illumination Change练习 287 范例9-7-1 Texture Flattening水彩化 288 范例9-7-2 水彩的世界-Live版 290 范例9-8-1 Seamless Cloning系列-澄清湖水怪无缝贴图 290 范例9-8-2 Seamless Cloning系列-背景练习 295 范例9-8-3 综合练习:使用多边形撷取无缝贴图实作练习 296 范例9-9-1 Non-Photorealistic Rendering非实感绘制-强化 300 范例9-10-1 非实感绘制系列-模糊影像边缘保留处理 301 范例9-11-1 非实感绘制系列-铅笔处理 302 范例9-12-1 非实感绘制系列-写实风格化 304 范例9-12-2 写实风格化Live版 305 范例9-13-1 具限制性对比度自适应直方图均衡CLAHE 306 范例9-14-1 影像形状自动校正 308 范例9-14-2 影像角度自动校正 311 第10章 检测 314 范例10-1-1 Hough Line霍夫线变换1 314 范例10-1-2 Hough Line霍夫线变换2 317 范例10-1-3线段检测 319 范例10-2-1 Hough Circle霍夫圆变换 321 范例10-2-2霍夫圆变换应用:距离量测使用Cam实作 324 范例10-2-3 综合应用-虚拟画笔Live版1 327 范例10-2-4 虚拟画笔Live版2 330 范例10-3-1 寻找轮廓 332 范例10-3-2 轮廓顺序表示法 334 范例10-4-1 寻找轮廓并且绘出外框矩形1 336 范例10-4-2 寻找轮廓并且绘出外框矩形2 338 范例10-4-3 多点绘出外框矩形1 341 范例10-4-4 多点绘出外框矩形2 342 范例10-4-5 多点绘出外框凸多边形 343 范例10-4-6 绘出多点外框圆形 345 范例10-4-7 绘出多点外框椭圆形 346 范例10-4-8 最近似外框多边形 347 范例10-4-9 绘出多点最适外框三角形 349 范例10-5-1寻找轮廓并且绘出外框圆形 351 范例10-5-2寻找轮廓并且绘出外框椭圆形 352 范例10-5-3寻找轮廓并且绘出外框三角形 354 范例10-6-1判断某点是否在凸边形的轮廓内 356 范例10-7-1计算轮廓的面积与周长 357 范例10-8-1使用匹配模板找出某物 359 范例10-8-2使用非匹配模板找出某物 363 范例10-8-3 修正使用匹配与非匹配模板找出某物 364 范例10-9-1 convexHull凸包处理 367 范例10-10-1 convexityDefects凸包缺陷 369 范例10-11-1颜色区域检测 373 范例10-12-1颜色辨识-反向投影1 377 范例10-12-2颜色辨识-反向投影2 379 范例10-12-3颜色辨识-反向投影3 380 范例10-13-1颜色辨识以RGB为主 381 范例10-13-2颜色辨识,使用HSV彩色空间 382 范例10-13-3影像颜色检测 384 范例10-14-1从webcam读取影像及判断HSV颜色值 385 范例10-14-2读取影像及调整HSV颜色值捕捉物体 387 范例10-14-3计算生锈面积 389 范例10-15-1综合应用,辨识蓝色圆形物 390 范例10-15-2综合应用:辨识蓝色圆形物-增加膨胀以改良 393 范例10-16-1找出肤色Live版 395 范例10-16-2找出肤色Live改善版 396 范例10-17-1手势、手指数目辨识 397 范例10-17-2手势控制相机先比5后比Ya(2指)触发自动拍照 406 范例10-18-1 Xray效果及找到手掌心 407 范例10-18-2找到手掌心 Live版 410 范例10-18-3找到掌心与手指 Live版 411 范例10-19-1 空间矩、中心矩、标准中心矩及Hu不变矩 411 范例10-19-2比较两个形状 416 范例10-19-3比较两个影像,使用直方图比对法 419 范例10-19-4找出某物整合MatchTemplete与compareHist 422 范例10-20-1 找出合适的切线 425 范例10-20-2 众点找出合适的切线 428 范例10-21-1束绳检测是否断裂1 430 范例10-21-2束绳检测是否断裂2 432 范例10-21-3束绳检测是否断裂3 433 范例10-22-1束绳检测是否偏斜1 435 范例10-22-2束绳检测是否偏斜2 437 范例10-22-3束绳检测是否偏斜3 439 范例10-23-1 综合应用:找出趋势图最高点 441 范例10-24-1寻找两个矩形的交叉点 442 范例10-25-1 捕抓萤幕画面 444 范例10-25-2找出应用程式在萤幕的位置-我的Word在那里 446 第11章 特征点检测 450 范例11-1-1 Shi-Tomasi角点检测方法 450 范例11-1-2利用角点检测找出particle-Live版 452 范例11-2-1 Harris-Stephens边缘检测方法 453 范例11-3-1更精确的角点检测 454 范例11-4-1特征点检测计算 457 范例11-5-1利用Features2D二维特征点寻找物体 462 范例11-5-2利用二维特征点SURF+FLANN寻找物体-Live版 468 范例11-5-3利用Features2D寻找近似物体 468 范例11-6-1利用二维特征点及Homography单映射寻找物体 472 范例11-6-2利用二维特征点及单映射寻找物体Live版 476 范例11-6-3利用二维特征点及单映射寻找近似物体 476 范例11-7-1客制化角点检测视窗 477 范例11-8-1寻找出棋盘格 480 范例11-8-2寻找出棋盘格Live版 483 范例11-9-1矫正镜头畸形 483 范例11-9-1利用矫正镜头制造艺术化扭曲影像 487 第12章 运动追踪motion tracking 489 范例12-1-1补捉动静Live版 489 范例12-2-1使用HOG特征进行行人检测 491 范例12-2-2行人检测Live版 494 范例12-3-1 Lucas-Kanade光流 494 范例12-3-2 Farneback光流 499 范例12-4-1使用MOG特征进行行人检测 502 范例12-4-2 MOG特征进行行人检测Live版 504 范例12-4-3使用KNN特征进行行人检测 505 范例12-4-4 KNN特征进行行人检测Live版 506 范例12-5-1使用Meanshift均值偏移寻找物体Live版 507 范例12-6-1使用CamShift人脸追踪Live版 509 范例12-7-1 Kalman Filter滤波,随机乱跑Live版 512 范例12-7-2 Kalman Filter滤波,追踪蓝色圆形Live版 516 范例12-8-1更新运动历史图像Live版 517 第13章 Machine Learning机器学习 523 范例13-1-1人脸辨识 524 范例13-1-2人脸辨识Live版 527 范例13-1-3人脸辨识含眼鼻Live版 527 范例13-1-4人脸眼鼻快速辨识Live版 529 范例13-1-5 整合应用:检测到眼睛自动添加眼镜Live版 531 范例13-1-6检测到眼睛自动添加半透明眼镜Live版 534 范例13-1-7检测行人 535 范例13-1-8检测车辆 537 范例13-1-9 DetectMultiScale3参数测试 538 范例13-1-10计算车流量 540 范例13-1-11 侦测RJ45网路头Live版 542 范例13-2-1 电脑小手写板程式Live版 549 范例13-2-1a手写数字的资料库 552 范例13-2-1b鸢尾花资料库 555 范例13-3-1常态贝叶斯分类器预测鸢尾花数据集 560 范例13-3-2常态贝叶斯分类器-预测手写数字 561 范例13-3-3常态贝叶斯分类器-预测手写数字Live版 563 范例13-4-1决策树Decision Trees预测鸢尾花数据集 565 范例13-4-2决策树-预测手写数字 569 范例13-4-3决策树-预测手写数字Live版 571 范例13-5-1最大期望值EM-预测鸢尾花数据集 572 范例13-5-2最大期望值-预测鸢尾花数据集二元分类 576 范例13-5-3最大期望值-预测鸢尾花数据集3类修改版 578 范例13-5-4最大期望值-预测手写数字 581 范例13-5-5最大期望值-预测手写数字(二元分类) 583 范例13-5-6最大期望值-预测手写数字Live版 586 范例13-6-1 Logistic回归-预测鸢尾花数据集 586 范例13-6-2 Logistic回归-预测手写数字 590 范例13-6-3 Logistic回归-预测手写数字,调整参数 593 范例13-6-4 Logistic回归-预测手写数字Live版 593 范例13-7-1 KNN-预测鸢尾花数据集 594 范例13-7-2 KNN-预测鸢尾花数据集2 597 范例13-7-3 KNN-预测手写数字 600 范例13-7-3 KNN-预测手写数字Live版 602 范例13-7-5 KNN-分类练习 602 范例13-8-1 随机森林-预测鸢尾花数据集 604 范例13-8-2随机森林-预测手写数字 607 范例13-8-3 随机森林-预测手写数字Live版 609 范例13-9-1 Boost分类-预测鸢尾花数据集 609 范例13-9-2 Boost分类-预测鸢尾花数据集2 612 范例13-9-3 Boost-预测手写数字 615 范例13-9-4 Boost-预测手写数字Live版 617 范例13-10-1 类神经网路-初声试啼小练习 618 范例13-10-2 类神经网路-预测鸢尾花数据集 623 范例13-10-3类神经网路-预测手写数字 625 范例13-10-4类神经网路-预测手写数字Live版 627 范例13-11-1 SVM-预测鸢尾花数据集 627 范例13-11-2 SVM预测手写数字 631 范例13-11-3 SVM预测手写数字Live版 633 范例13-11-4 SVM分类练习于2D平面 633 范例13-12-1 Kmean(K均值)简单分类 636 范例13-12-2 Kmean 1维数据分类 640 范例13-12-3 Kmean 2维数据分类 643 范例13-12-4 Kmean 应用于影像处理-减色处理 646 范例13-12-5 Kmean预测分类-鸢尾花数据集 648 范例13-12-6 Kmean预测分类-手写数字数据集 650 范例13-12-7 Kmean预测分类-手写数字Live版 652 范例13-13-1马氏距离 654 范例13-13-2马氏距离使用于-鸢尾花数据集 656 范例13-13-3马氏距离使用于-手写数字数据集 657 范例13-13-4修改马氏距离使用于-手写数字数据集 660 范例13-13-5修改马氏距离使用于-鸢尾花数据集 665 范例13-13-6修改版马氏距离使用于-预测手写数字Live版 666 范例13-14-1主成份分析PCA 671 范例13-14-2鸢尾花数据集使用PCA降维 673 范例13-14-3鸢尾花数据使用PCA降维整合Kmean聚类处理 675 范例13-14-4鸢尾花数据使用PCA降维整合Knn分类处理 678 范例13-14-5手写数字集使用PCA降维整合Kmean聚类处理 680 范例13-14-6 手写数字集使用PCA降维整合KNN及SVM分类 682 范例13-14-7 改善手写数字集使用PCA降维整合KNN及SVM 685 范例13-14-8 改善鸢尾花数据使用PCA降维整合KNN分类 689 范例13-14-9个人人脸辨识整合PCA与SVM计算 690 范例13-14-10个人人脸辨识整合PCA与LibSVM计算 694 范例13-15-0车牌辨识 699 范例13-15-1 Java呼叫外部命令Tesseract字符识别引擎 701 第14章 其它功能与整合效果 703 范例14-1-1离散傅立叶转换 703 范例14-2-1视差(视角不对称)使用BM 706 范例14-2-2视差(视角不对称)使用SGBM 708 范例14-3-1综合应用:虚拟钢琴Live版 710 范例14-4-1平面细分割使用Subdiv2D 711 范例14-4-2综合练习,平面细分割使用Subdiv2D应用于人脸 715 范例14-4-2综合练习,平面细分割应用人脸Live版 718 第15章 发行Java应用程式 721 第16章 Opencv与Web整合 723 范例16-1-1 Hello Opencv 723 范例16-1-2 利用opencv显示影像 726 范例16-1-3在Web上模糊处理 729 范例16-1-4 jsp应用模糊处理 730 附录A Opencv Mat资料结构列表 734 附录B Opencv色彩空间转换资料格式列表 736 附录C Iris鸢尾花数据集 743 附录D Opencv Java开发异常说明 748 附录E Opencv for Java 2.4.12与3.1差异 749 附录F Opencv相关网址 754

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值