算法工程师--图像相关

图像处理

1. 下列算法中属于图像锐化处理的是高通滤波。
2. 图像编码的目的是压缩数据、减少图像存储空间、提高图像传输效率。(个人理解)
3. 图像边缘检测算子有Sobel算子、Roberts算子、Prewitt算子、Laplacian算子和Canny算子。
4. 下列算法中，属于点处理的是傅里叶变换。
   a. 二值化 b. 梯度锐化 c.中值滤波 d.傅里叶变换
5. 下列压缩编码方式中，有损压缩是DCT编码
   a. 算术编码 b. Huffman编码 c.香农编码 d. DCT编码
6. 采用模板$\begin{bmatrix}-1\\1 \end{bmatrix}$主要检测水平方向的边缘。

模式识别

1. 模式识别系统的基本构成单元包括： 模式采集、特征提取与选择和模式分类。
2. 统计模式识别中描述模式的方法一般使用特征矢量；句法模式识别中模式描述方法一般有串、 树、 网。
3. 聚类分析算法属于无监督分类，判别域代数界面方程法属于统计模式识别方法。
4. 若描述模式的特征量为0-1二值特征量，则一般采用匹配测度进行相似性度量。
5. Fisher线性判别函数的求解过程是将N维特征矢量投影到一维空间中进行。
6. 下列判别域界面方程法中只适用于线性可分情况的算法有感知器算法；线性可分、不可分都适用的有积累位势函数法。
7. 模式识别的基本方法有数据聚类、神经网络、统计分析和结构模式识别。(个人理解)
8. 聚类属于非监督学习，分类属于监督学习，回归属于监督学习。

编程能力

• unsigned char* pucImage 指向一副200*100大小的8位灰度图像数据，写一段C语言代码，统计该图像的直方图信息。

int *pucImgHist(unsigned char* pucImage) {
    int height = 100;
    int width = 200;
    int *pHist = new int[256];
    memset(pHist, 0, 256*sizeof(int));
    unsigned char* pData = NULL;
    for (int j=0; j<height; j++) {
        pData = pucImage + j * width;
        for (int i=0; i<width; i++) {
            pHist[*pData]++;
            pData++;
        }
    }
    return pHist;
}

• 编程实现二分查找。

int searchBy2Division(int array[], int n, int v) {
    int left, right, middle;
    left = 0, right = n-1;
    while(left <= right) {
        middle = left + (right - left) / 2;
        if (array[middle] > v){
            right = middle - 1;
        } else if (array[middle] < v) {
            left = middle + 1;
        } else {
            return middle;
        }
    }
    return -1;
}

Code Snippets

//
//  histEdge.c
//  detectCorner
//
//  Created by tianzhaixing on 16/6/13.
//  Copyright © 2016年 johntian. All rights reserved.
//

#include <stdio.h>
#include <stdlib.h>

#include <opencv2/core/core_c.h>
#include <opencv2/highgui/highgui_c.h>
#include <opencv2/imgproc/imgproc_c.h>

int main()
{
    IplImage *pSrcImg = cvLoadImage("./lena.jpg", 1);
    if (pSrcImg == NULL)
    {
        printf("Fail to load image!\n");
        return -1;
    }
    // width, height, step, channel
    int height = pSrcImg->height;
    int width = pSrcImg->width;
    int step = pSrcImg->widthStep;
    int channel = pSrcImg->nChannels;
    uchar *pSrcData = (uchar *)pSrcImg->imageData;
//    printf("%d", channel);

    // --color to gray
    IplImage *pGrayImg = cvCreateImage(cvSize(width,height),IPL_DEPTH_8U,1);
    uchar *pGrayData = (uchar *)pGrayImg->imageData;
    uchar bgr[3];
    uchar gray = 0;
    for (int i=0;i<height;i++)
    {
        for (int j=0;j<width;j++)
        {

            for (int k=0;k<channel;k++)
            {
                bgr[k] = pSrcData[i*step+j*channel+k];
            }
            gray = (uchar)(0.114*bgr[0] + 0.587*bgr[1] + 0.299*bgr[2]);
            pGrayData[i*width+j] = gray;
        }  
    }
//    cvNamedWindow( "gray", 0);
//    cvShowImage( "gray", pGrayImg);
//    cvWaitKey(0);
//    cvDestroyWindow( "gray");

    // --gray histogram
    int pHist[256];
    memset(pHist, 0, sizeof(int)*256);
    pGrayData = (uchar *)pGrayImg->imageData;

    for (int i=0; i<height; i++) {
        for (int j=0; j<width; j++) {
            gray = pGrayData[i*width + j];
            pHist[gray]++;
        }
    }
//    for (int i=0; i<256; i++) {
//        printf("%d--> %d\n", i, pHist[i]);
//    }

    // --gray sobel edge
    IplImage *pEdgeImg = cvCreateImage(cvSize(width,height),IPL_DEPTH_8U,1);
    uchar *pEdgeData = (uchar *)pEdgeImg->imageData;
    pGrayData = (uchar *)pGrayImg->imageData;
    int w = 3, k = 0;
    uchar grayW[w*w];
    // sobelx  sobely
    // -1 0 1  -1 -2 -1
    // -2 0 2   0  0  0
    // -1 0 1   1  2  1
    int sobelx[9] = {-1, 0, 1, -2, 0, 2, -1, 0, 1};
    int sobely[9] = {-1, -2, -1, 0, 0, 0, 1, 2, 1};
//    for (int ik=0; ik<w*w; ik++) {
//        printf("soblex=%d, sobely=%d\n", sobelx[ik], sobely[ik]);
//    }
    int sx = 0, sy = 0;

    for (int i=1; i<height-1; i++) {
        for (int j=1; j<width-1; j++) {
             // 方法1
//            sx = -1*pGrayData[(i-1)*width + j-1] + 0*pGrayData[(i-1)*width + j] + 1*pGrayData[(i-1)*width + j+1] +
//                 -2*pGrayData[i*width + j-1] + 0*pGrayData[i*width + j] + 2*pGrayData[i*width + j+1] +
//                 -1*pGrayData[(i+1)*width + j-1] + 0*pGrayData[(i+1)*width + j] + 1*pGrayData[(i+1)*width + j+1];
//            sy = -1*pGrayData[(i-1)*width + j-1] + -2*pGrayData[(i-1)*width + j] + -1*pGrayData[(i-1)*width + j+1] +
//                 0*pGrayData[i*width + j-1] + 0*pGrayData[i*width + j] + 0*pGrayData[i*width + j+1] +
//                1*pGrayData[(i+1)*width + j-1] + 2*pGrayData[(i+1)*width + j] + 1*pGrayData[(i+1)*width + j+1];
//            pEdgeData[i*width+j] = sx/2 + sy/2;

            // 方法2
            // w*w 窗口
            k = 0;
            for (int m=-w/2; m<=w/2; m++) {
                int x = i + m;
                x = (x >= 0 ? (x < height ? x : height-1) : 0);
                for (int n=-w/2; n<=w/2; n++) {
                    int y = j + n;
                    y = ( y >= 0? (y < width ? y : width-1) : 0);
                    grayW[k] = pGrayData[x*width + y];
                    k += 1;
                }
            }
            // sobel
            sx = 0, sy = 0;
            for (int ik =0 ; ik < w*w; ik++) {
                sx += grayW[ik]*sobelx[ik];
            }
            for (int ik =0 ; ik < w*w; ik++) {
                sy += grayW[ik]*sobely[ik];
            }
            pEdgeData[i*width+j] = sx/2 + sy/2;
        }
    }

    cvNamedWindow( "edge", 0);
    cvShowImage( "edge", pEdgeImg);
    cvWaitKey(0);
    cvDestroyWindow( "edge");
    return 0;
}