Come world to Record life

简述

之前一直没有注意过科学上网的问题，因为平常不怎么需要，改个hosts文件登个google也就够用了。直到最近才发现，其实在教育网中，本身就可以利用ipv6地址进行绕过GFW访问google,facebook,twitter,youtube等等，而且甚至还不需要登网关（当然，不登网关反而只能访问国外的IPv6网址，对于很多ipv4的网址反而无法访问）。当然，这种不登陆网关就访问其他网站的行为并不能算是作弊，这只能算是对ipv6资源的合理利用，这是学校鼓励并推荐使用的。但是可惜的是，很多同学并没有充分的利用这个资源，在6rank中可以查看到这个资源使用的情况，基本上大部分的高校对ipv6的使用率都不到1%。。。

配置

ipv6的配置其实特别简单，只要你的网段给你的机子分配了ipv6的地址，就完全可以通过简单的修改ipv6的hosts达到访问国外ipv6网址的效果。

查看是否支持ipv6

尽管大部分的高校都接通了ipv6，但是有的高校还没有接入，而且接入ipv6的高校中在有些位置也并没有做到完全覆盖，因此还是要先确认下首先要支持ipv6再行折腾。

首先确认下电脑是否支持ipv6：windows下在cmd中输入ipconfig ，查看是否有Ipv6地址项；在Linux下输入ifconfig ，查看是否有inet6地址项，如果有，就说明你的电脑有ipv6的地址。

然后确认下网络是否支持ipv6：有一个项目叫kame.net，登陆进这里，如果能看到动态的小乌龟就说明网络是支持ipv6的。

修改hosts

ipv6说白了跟ipv4一样，对于国外的主机还是缺少dns解析这一步，因此我们还是需要通过各种手段找到ipv6的域名跟ip的对应关系，写在hosts文件里，这样才能直接通过域名来访问。

windows中在c:\User\Administrator\system32\drivers\etc\hosts下，Linux中在/etc/hosts下。

至于这个文件的内容从哪里找，我个人是在https://serve.netsh.org/pub/ipv6-hosts/中看的，这个应该算是比较官方的。

清除缓存

上面的操作基本就OK了，但是一般这时候还要清除下浏览器的缓存，因为为了提高效率，如果这次发送的http请求和之前发送的http请求一模一样，很多浏览器都会直接从缓存中提取内容而不去获取最新的消息。windows下还需要在cmd中输入ipconfig/flushdns，ubuntu下在shell下输入sudo service networking restart。

通过以上配置，我们就可以直接访问ipv6的地址了，由于普通的校园网关只对ipv4加以限制，因此ipv6的部分并不需要连接网关就可以登陆。而且ipv6的网络速度还格外的快，访问facebook甚至比访问百度还快！

相关信息

CNGI高校驻地网IPv6用户数量测试
为何Ipv6难以普及
奶齿网发布的ipv6信息
Ipv6测试网

Gamma矫正这个东西听上去挺玄乎，其实特别简单。就是为了调节照相机拍摄的图像的色调，使他更加符合人眼的观测效果（主要用在）。说白了就是一种幂函数型的色调曲线，即对于每个像素的灰度$I$我们把他变成$I^{gamma}$，当然，在这之前，我们得把灰度值$I$归一化到(0,1)的范围内。

这个gamma分为大于一和小于一的情况。当他大于一的时候，很明显这个幂函数在(0,1)的区间内是下凸的，图像会变暗；当他小于一的时候，这个幂函数在(0,1)的区间内是上凸的，图像会变亮。通常认为人眼的gamma值大概是0.45左右。姑且信了。

说实话这个东西我还没觉得有啥用处。实现起来也非常简单：

1
2
3
4
5
6
7

import cv2
import numpy as np
from pylab import *

imshow((cv2.imread('lena.png',0)/255.0))
imshow((cv2.imread('lena.png',0)/255.0)**5)
imshow((cv2.imread('lena.png',0)/255.0)**0.5)

计算图像的梯度是在进行图像处理时经常用到的方法，但是这玩意自己手写未免效率低而且容易出错。OpenCV里集成了相应的函数，只不过用的人好像并不多导致我找了半天才找到。姑且记一下以备日后使用。

计算像素梯度的绝对值

这个用到了cv2.magnitude方法，具体用法如下：

1
2
3

sobelx=cv2.Sobel(im,cv2.CV_64F,1,0,ksize=3)#1,0表示只在x方向求一阶导数
sobely=cv2.Sobel(im,cv2.CV_64F,0,1,ksize=3)#0,1表示只在y方向求一阶导数
mag=cv2.magnitude(x,y)

这里传入两个参数，分别是x和y方向的梯度，这里我用的是Sobel算子分别求x和y方向的梯度，卷积核的大小我设置的是３。得到的mag就是对应每个像素的梯度矩阵。实际上这也可以算成边缘检测吧。

对于Sobel函数有个注意点，他的第二个参数是扩展了像素的数值范围，因为梯度是有方向的，所以sobel函数得到的是有正有负的值，所以相当于扩大了取值。通常情况下我们会加上下面的函数来得到梯度的绝对值：

1

sobelx=cv2.convertScaleAbs(cv2.Sobel(im,cv2.CV_64F,1,0,ksize=3))

在外面套一个取绝对值的函数，或者也可以直接套一个np.abs()。。。不过效果不太一样。

计算像素梯度的方向

这个用到了cv2.parse方法，具体用法如下:

1

phase= cv2.phase(cv2.Sobel(im,cv2.CV_64F,1,0,ksize=3),cv2.Sobel(im,cv2.CV_64F,0,1,ksize=3),angleInDegrees=True)

Sobel的用法跟上面一样，最后一个参数为True表示结果用角度制表示，否则用弧度制。

得到的结果通常会用直方图来表示，

1

hist(phase.ravel(),256,[0,256])

输出的图像就是梯度按照角度的分布。

之前一直使用的是Apache服务器，对于Tomcat的工作方式反而不那么习惯。给我一个Java web程序源码我都不晓得他应该怎么连接到Tomcat上。于是趁着无聊的时候看了个J2EE的Servlet教程，终于对怎么把java部署到Tomcat上、以及Tomcat的基本工作流程有了简要的认识。当然，这里仅仅指的是简单的Servlet程序的部署方法，不过这点方法从理论上讲已经具备了写一个简单web 应用的能力了。

Tomcat基本配置

Tomcat的配置文件是%TOMCAT_HOME%/conf/server.xml，这里配置了Tomcat的基本信息，最重要的是下面这两个：

1
2
3

<Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

1
2

<Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">

第一个指定了Tomcat监听的端口，默认是8080，如果和其他应用冲突了可以在这里修改。

第二个指定了Tomcat映射的根目录，就像apache中的/var/www/html/的作用一样，但又不完全一样。因为这下面放的都应该是一套完整的应用而不是单一的html文件。

HttpServlet类基本用法

Servlet程序就是服务器小程序，现在我们的目的是编写web服务器，那么自然就用到了HttpServlet类来实现一个Http服务器应用。它的基本框架是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/MyServlet")
public class MyServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		response.getWriter().append("<a href='http://www.baidu.com'>baidu</a>");
	}
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}

}

这里最常用的就是重载它的doGet和doPost方法，每个方法都传入Request和Response方法，可以从Request中读入用户传过来的数据，并且将需要显示的内容写在Response中，这样就可以达到简单的动态显示网页的效果了。（注意加@WebServlet标注）

Webapps下项目基本配置

这个是Tomcat和Apache非常不同的东西，也是我花了半天才理清楚的。

把Servlet应用放在Webapps文件夹下必须要有web.xml配置文件，这个文件应该放在 项目根目录/WEB-INF/ 下，这是用来配置整个项目的配置文件。他一定要有如下格式：

1
2
3
4
5
6
7
8
9

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
  version="3.1"
  metadata-complete="true">

</web-app>

实际上就是把%TOMCAT_HOME%/conf/web.xml文件的中间部分去掉，留下了外壳，以后需要在这里面慢慢添加配置文件。

当然， 为了让他能访问到一个特定的Servlet程序，我们还要的对他进行注册:

首先，我们要把编译过的MyServlet.class文件放在WEB-INF/下的classes/文件夹下；

然后，在上面的web.xml中间写入这样的内容:

1
2
3
4
5
6
7
8
9

<servlet>
      <servlet-name>MyServlet</servlet-name>
      <servlet-class>MyServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>MyServlet</servlet-name>
        <url-pattern>/MyServlet</url-pattern>
    </servlet-mapping>

意思很清楚，就是对这个Servlet起个名字，然后把他映射到项目根目录下的MyServlet上，这样就能够通过浏览器访问到了。（事实上，上面的操作的目的就是之前那个类文件中的@WebServlet("/MyServlet") 。

上面是比较基础的操作方法，如果是用Eclipse的话就简单的很了，什么配置web.xml啊，新建文件夹啊都不用操心，只要新建动态网页应用，写个Servlet类，然后直接就能跑起来。不过有一个要注意的就是在用Eclipse查看浏览页面的时候是不用手动开启Tomcat服务器的，如果手动开了的话还会报错。

最近一直在用Python写代码，发现了很多代码重复的问题，总是复制粘贴显得特别凌乱，于是就想用类来封装一下。下面就记录下Python中最基础的面向对象编程方法。python的面向对象跟java，c++的面向对象意思都差不多，从他们类比过来还是非常好理解的。

类定义

python的类定义比较简单格式基本是这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Test():

    publicAttr= 0

    def __init__(self):
        pass

    def instanceMethod(self):
        pass

    @staticmethod
    def staticMethod():
        pass

    @classmethod
    def classMethod(cls):
        pass

    def __del__():
        pass

• 直接定义一个Test类，括号里面表示他的父类，默认是Object。
• 构造函数名字叫__init__，括号内表示构造的参数，但是第一个参数必须是self，表示传入自己的引用，而且之后调用的所有类属性类方法都需要用self来引导。
• 类的方法分为实例方法、静态方法和类方法。除了实例方法外，其他方法是在方法上方用‘@staticmethod’或‘@classmethod’来表示的。而且只有实例方法必须先生成一个实例才可以调用。
• 注意类方法默认传入的参数不是self，而是cls，表示他是类方法。类方法跟静态方法基本差不多，不同的就是这个参数，以及在继承中的差异。
• 析构函数名字叫__del__，传入self参数。由于python本身具有垃圾回收机制，我们既可以用del myinstance来显式调用，也可以让系统自己调用。

权限控制

python中并没有权限控制的关键字，所以默认的权限都是public，他相信程序员知道自己正在做什么。不过他也提供了权限控制的机制，就是通过方法名。如果方法名或属性名前面由‘__’修饰，那么python就认为他是私有的。

比如:

1
2
3
4
5
6
7
8
9
10
11
12
13

class Test():
    __privateAttr=1
    publicAttr= 2
    def __privateMethod(self):
        print self.__private
    def publicMethod(self):
        print self.publicAttr

test=Test()             #constructor
print test.publicAttr
#print test.__privateAttr
test.publicMethod()
#test.__privateMethod()

类外部调用私有属性是会报错的。

不过事实上，私有属性也是可以在类外被访问到的，只要在他的名字前面加上“_类名”就可以了。

继承

python支持多重继承（具体内容暂时不研究），父类名写在类声明的括号里面。具体用法跟其他的支持OOP语言的使用方法类似。

突然被要求搭建个Java 动态网页开发环境，好久不用eclipse的我着实懵逼好久。这当中遇到了好多好多的坑，姑且记录下一些注意事项，加深下对Eclipse和Tomcat的理解。

• java环境和Tomcat的环境一定要搭建正确，windows下注意配置下环境变量即可，ubuntu下还要注意尽量要自己下载源码编译，不要用apt-get里面的包。。。apt-get里的东西满满的都是坑，懒人化操作固然方便，但是这就导致了我们对他的路径、环境变量的存储位置都不清楚，这对接下来的配置会带来极大的困难。

• eclipse的版本一定要看准了，不一定要是最新的，但是尽量用eclipse for j2ee 版本的。虽说理论上任何的eclipse版本之间都可以通过安装插件来达到同样的效果，但是这还是有很多不一样的地方。当你对着教程学习的时候，发现自己的菜单选项和人家的选项不一样的时候还是非常的蛋疼的。

• eclipse在配置Server的时候一定要选择到我们下载的Tomcat路径。因为无论我们是否安装了Tomcat，在preference->server->runtime environment 选项中eclipse总会提供所有的Tomcat版本供我们选择，然而这些并没有卵用，如果想让eclipse连接本机的Tomcat，必须在search选项中选择Tomcat安装路径。这样选择的server才能用。

• 一定要添加全所有需要的jar包，在build path里添加需要的包（这里通常有很多很多，比如struts，spring，javax，json之类的），尤其是Tomcat的包（即javax之类的包，如果不是eclipse for j2ee的话是很难找到的）。而且还要注意选择jre包，选择不对的话是会报错的，而且很难看出来。

• 一定要记得，要在WEB-INF/lib/文件夹下把之前build path中添加的包通通添加进来， 否则会迷之报错，最典型的就是在Tomcat启动时报类似“Error configuring application listener of class org.springframework.web.context.ContextLoaderListener”的错误。。。话说报这个错的时候谁会想到是因为jar包没有加对地方造成的。。。另外提一句，如果是绕过eclipse直接在Tomcat中启动项目的话，还得会看日志，日志文件是在%TOMCAT_HOME%/logs/catalina.out文件中。如果不会看日志文件，你看到的只能是404 not found，并不能研究错误是什么。。。

• 通常情况下，第一次在Tomcat里跑自己的项目肯定会报类似这样的错误“The Apache Tomcat Native library which allows optimal performance in production environments was not found...”这是因为我们缺少APR（Apache Portable Runtime）这个东西，在windows下可以直接下tcnative-1.dll文件，并放在c:/windows/system32/下（注意选择架构）。如果是在ubuntu下就有点麻烦了，还得去下apr和apr-util文件来配置编译。。。甚是麻烦以至于我到现在都没弄好。。。

差不多上面就是我搭建Eclipse+Tomcat服务器遇到的问题和解决的方法。以后遇到问题还是要善于去找日志文件，并勤于利用搜索引擎，这样才能将问题进行有针对性的解决。

一直听说用Markdown写博文挺方便的，也一直没有在意，然而最近在用jupyter的时候突然发现jupyter是自带Markdown的，这让没用过的我很是尴尬。而且后来在网上翻博客的时候，发现“简书” 上的博客格式都非常漂亮，特别是层次非常清楚，排版也和工整，后来才知道这个就是用markdown写的。于是我也萌生了一个用markdown写文章的想法。 当然在这之前，肯定要了解下markdown的语法什么的。

平台

首先我需要一个Linux下写Markdown的小工具，有一个开源的小软件叫‘retext’（用pyqt写的）能够挺好的支持markdown的语法的。

如果是在web上直接写markdown，也有很多平台，百度一下就晓得了。当然，类似jupyter、简书甚至wordpress也都能够很好的支持markdown

用法

用法十分简单，一张表就可以基本解决：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#Header 1
##Heaer 2
###Header 3
####header 4
#####header 5
######header 6

Header
====

SubHeader
----

**bold**

*italics*

*emphasize*

label [^1]

> This is the quote

    #include<iostream>
    using namespace std;
    int main(){
        printf("hello world\n");
    }

[This is the label](http://www.baidu.com)

![alt](/images/2016/03/14/1/1.png)

*  1
* * 1
* * * 1

[^1]: This is my first footnote

效果图

需要说明的几点：

• 换行是用位于行末的两个空格来确定的，而不是直接回车。
• 代码是用同一的一个缩进位来表示的。
• 引用链接是用[text](url)来确定的，如果是引用图片，则在前面加！号即可。
• 标注是用[^n]来确定的，在需要使用的时候用[^n]，在文章末尾用[^n]:description来加以说明。
• 多级分点是用*来表示的，当然，多个*之间要有空格。
• 其他用法可以查看文档

Markdown之所以这么红，我想就是因为他的宗旨非常切合大众的需要，那就是“成为一种适用于网络的书写语言”，他的宗旨就是易读易写。这也就难怪他成为写博客，构建cms站点，甚至是写论文的一个非常好的工具了。

直方图均衡化方法属于图像增强的范畴，是一种对图像进行灰度级修正的方法。简而言之，就是对一个灰度图像进行处理，使他的特征更加明显。通常情况下，在对图像进行进一步的处理之前，直方图均衡化是一种对灰度进行归一化处理的好方法，而且也可以增强图像的对比度。

概述

这个方法的思路非常简单，就是我们把一个灰度图像以0-255个灰度值为横坐标，灰度对应的像素点的个数为纵坐标，构成一个灰度直方图。对于那些灰度分布非常不均衡的图像来说，我们要做的就是通过对灰度值进行一个映射，将他灰度直方图尽可能的拉伸。通常情况下我们可以对他的累计分布函数（CDF）进行线性插值即可，实现起来也很简单。

用法

当然我们并不需要每次都自己写，调用matplotlib的函数可以很轻松的画出直方图，调用OpenCV的函数可以很轻松的进行均衡化：

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# coding: utf-8

import Image,cv2
import numpy as np
from pylab import *

raw=Image.open('test.png')
im=np.array(raw.convert('L'))

gray()
figure()
hist(im.ravel(),256,[0,256])#matplotlib的函数，hist用来绘直方图，ravel是将二维图像数组转换成一维数组
xlim([0,256])

equ=cv2.equalizeHist(im)    #OpenCV直方图均衡化的接口
figure()
hist(equ.ravel(),256,[0,256])
xlim([0,256])

figure()
imshow(raw)

res=np.hstack((im,equ))    #将两个图像水平合并方便查看
figure()
imshow(res)

show()

效果

为了提高验证码的识别准确率，我们当然要首先得到足够多的测试数据。验证码下载下来容易，但是需要人脑手工识别着实让人受不了，于是我就想了个折衷的办法——自己造验证码。

为了保证多样性，首先当然需要不同的字模了，直接用类似ttf格式的字体文件即可，网上有很多ttf格式的字体包供我们下载。当然，我不会傻到手动下载解压缩，果断要写个爬虫了。

网站一：fontsquirrel.com

这个网站的字体可以免费下载，但是有很多下载点都是外链连接到其他网站的，这部分得忽略掉。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#coding:utf-8
import urllib2,cookielib,sys,re,os,zipfile
import numpy as np

#网站登陆
cj=cookielib.CookieJar()
opener=urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
opener.addheaders=[('User-agent','Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.106 Safari/537.36))')]
urllib2.install_opener(opener)

#搜索可下载连接
def search(path):
    request=urllib2.Request(path)
    response=urllib2.urlopen(request)
    html=response.read()
    html=html.replace('\n',' ')#将所有的回车去掉，因为正则表达式是单行匹配。。。。。。
    urls=re.findall(r'<a href="(.*?)">(.*?)</a>',html)
    for i in urls:
        url,inner=i
        if not re.findall(r'Download ',inner)==[] and re.findall(r'offsite',inner)==[] and url not in items:
            items.append(url)

items=[]#保存下载地址

for i in xrange(15):
    host='http://www.fontsquirrel.com/fonts/list/find_fonts/'+str(i*50)+'?filter%5Bdownload%5D=local'
    search(host)

if not os.path.exists('ttf'):
    os.mkdir('ttf')
os.chdir('ttf')

def unzip(rawfile,outputdir):
    if zipfile.is_zipfile(rawfile):
        print 'yes'
        fz=zipfile.ZipFile(rawfile,'r')
        for files in fz.namelist():
            print(files)  #打印zip归档中目录
            fz.extract(files,outputdir)#解压缩文件
    else:
        print 'no'

for i in items: 
    print i
    request=urllib2.Request('http://www.fontsquirrel.com'+i)
    response=urllib2.urlopen(request)
    html=response.read()
    name=i.split('/')[-1]+'.zip'
    f=open(name,'w')
    f.write(html)
    f.close()#文件记得关闭，否则下面unzip会出错
    unzip(name,'./')
    os.remove(name)

os.listdir(os.getcwd())
os.chdir('../')

files=os.listdir('ttf/')
for i in files:#删除无用文件
    if not (i.split('.')[-1]=='ttf' or i.split('.')[-1]=='otf'):
        if os.path.isdir(i):
            os.removedirs('ttf/'+i)
        else:
            os.remove('ttf/'+i)

print  len(os.listdir('ttf/'))

搞到了2000+个字体，种类也挺多的，蛮好。

网站二：dafont.com

这个网站的字体花样比较多，下载起来也比较方便，恶心的是他的文件名的编码好像有点问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

#coding:utf-8
import urllib2,cookielib,sys,re,os,zipfile
import shutil
import numpy as np

cj=cookielib.CookieJar()
opener=urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
opener.addheaders=[('User-agent','Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.106 Safari/537.36))')]
urllib2.install_opener(opener)

items=[]

def search(path):
    request=urllib2.Request(path)
    response=urllib2.urlopen(request)
    html=response.read()
    html=html.replace('\n',' ')
    urls=re.findall(r'href=\"(http://dl.dafont.com/dl/\?f=.*?)\" >',html)
    items.extend(urls)

for i in xrange(117):
    host='http://www.dafont.com/new.php?page='+str(i+1)
    search(host)
    print 'Page'+str(i+1)+'done'
    items=list(set(items))
    print len(items)

if not os.path.exists('ttf2'):
    os.mkdir('ttf2')
os.chdir('ttf2')

def unzip(rawfile,outputdir):
    if zipfile.is_zipfile(rawfile):
        print 'yes'
        fz=zipfile.ZipFile(rawfile,'r')
        for files in fz.namelist():
            print(files)  #打印zip归档中目录
            fz.extract(files,outputdir)
    else:
        print 'no'

for i in items: 
    print i
    request=urllib2.Request(i)
    response=urllib2.urlopen(request)
    html=response.read()
    name=i.split('=')[-1]+'.zip'
    f=open(name,'w')
    f.write(html)
    f.close()
    unzip(name,'./')
    os.remove(name)

print os.listdir(os.getcwd())

for root ,dire,fis in os.walk('./'):#递归遍历文件夹
    for i in fis:

        if not (i.split('.')[-1]=='ttf' or i.split('.')[-1]=='otf'):
            os.remove(root+i)
            print i

for i in os.listdir('./'):
    if os.path.isdir(i):
        os.rmdir(i)
os.chdir('../')

总体操作跟之前的差不多，跑了几十分钟下了4000多的字体。

最近处理到游侠网的验证码，学习了一点东西，聊作记录。

游侠网的验证码总体来讲比较简单，字符分割比较清楚。稍微有难度的地方就是处理他的阴影。

** 示例 **

很明显，如果直接拿这种图去跑机器学习算法的话肯定准确率不高，必然需要进行灰度或者二值化。当然，二值化是比较好的选择。

但是由于灰度分布是不均匀的，如果采用类似OTSU的全局阈值显然会造成分割不准，而局部阈值分割的Bersen算法则非常适合处理这种情况。

OTSU算法得到的图像：

1
2
3
4
5
6
7

import cv2
from pylab import *

im=cv2.imread('source.png',cv2.IMREAD_GRAYSCALE)
cv2.imwrite('source.png',im)
thresh,im=cv2.threshold(im,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
cv2.imwrite('OTSU.png',im)

Bersen算法

原始的Bersen算法很简单，对于每一个像素点，以他为中心，取一个长宽均为((2w+1)^2)的核；对于这个核，取当中的极大值和极小值的平均值作为阈值，对该像素点进行二值化。然后将这个过程应用到整张图即可。

这个也很好理解，只要取一个适当的核的大小w，就可以在每一个局部内取得一个较好的阈值而不去考虑全局的其他像素。但是这有一个问题，就是他对噪声比较敏感，毕竟每一个像素点的取值仅仅依赖于附近区域内的极大极小两个值。因此实际操作中通常不是取极大极小值，而是取整个核的平均值或是加权平均值。具体操作下来通常就是用一个高斯平滑滤波。

实现效果

算法比较简单，而且OpenCV里直接给了个函数调用，方便省事。

1
2
3
4
5
6
7
8
9

import cv2
from pylab import *
%matplotlib inline

im=cv2.imread('13.png',cv2.IMREAD_GRAYSCALE)
im=cv2.adaptiveThreshold(im,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,11,2)
cv2.imwrite('mean.png',im)
im=cv2.adaptiveThreshold(im,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,2)
cv2.imwrite('gaussian.png',im)

分别用平均加权和高斯加权显示。。效果差不多，都挺好的。这里的倒数第二个参数就是卷积核的大小，最后一个参数是像素的矫正，即将实际算得的像素减去这个值得到结果。