简述：
 
        根据CASIA的HWDB1.X的手写字符生成了一些带有字符级标注、行级别标注的文本数据，分享给需要的同学。
 
 生成基于不同人的字体、字体大小、行间字体间隔、旋转角度、文本布局的文字贴图。
 生成素材：共65种贴图背景， 由420位手写字体作者完成的71,122个符号， 1,609,136个汉字/3,866类。
 数据量：Train:2597张， Test：662张，目前完了HWDB1.0部分，part2，part3如果需要后期可以继续制作。
字符素材：
 
 
数据示例：
 
     
 
字符级标注信息：
 
 
行级标注信息：
 
 
CASIA HWDB数据下载地址：http://www.nlpr.ia.ac.cn/databases/handwriting/Download.html
 
欢迎加入OCR交流群，在群文件中可以直接领取生成数据~~~
 

 
先放结果
 

 
这是通过GAN迭代训练30W次，耗时3小时生成的手写字图片效果，大部分的还是能看出来是数字的。
 
实现原理
 
简单说下原理，生成对抗网络需要训练两个任务，一个叫生成器，一个叫判别器，如字面意思，一个负责生成图片，一个负责判别图片，生成器不断生成新的图片，然后判别器去判断哪儿哪儿不行，生成器再不断去改进，不断的像真实的图片靠近。
 
这就如同一个造假团伙一样，A负责生产，B负责就鉴定，刚开始的时候，两个人都是菜鸟，A随便画了一幅画拿给B看，B说你这不行，然后A再改进，当然需要改进的不止A，随着A的改进，B也得不断提升，B需要发现更细微的差异，直至他们觉得已经没什么差异了(实际肯定还存在差异)，他们便决定停止"训练"，开始卖吧。
 
实现代码
 
# -*- coding: utf-8 -*-
 
# @author: Awesome_Tang
 
# @date: 2019-02-22
 
# @version: python2.7
 
import tensorflow as tf
 
from tensorflow.examples.tutorials.mnist import input_data
 
from datetime import datetime
 
import numpy as np
 
import os
 
import matplotlib.pyplot as plt
 
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
 
class Config:
 
alpha = 1e-2
 
drop_rate = 0.5 # 保留比例
 
steps = 300000 # 迭代次数
 
batch_size = 128 # 每批次训练样本数
 
epochs = 100 # 训练轮次
 
num_units = 128
 
size = 784
 
noise_size = 100
 
smooth = 0.01
 
learning_rate = 1e-4
 
print_per_step = 1000
 
class Gan:
 
def __init__(self):
 
print('Loading data......')
 
# 读取MNIST数据集
 
self.mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
 
# 定义占位符，真实图片和生成的图片
 
self.real_images = tf.placeholder(tf.float32, [None, Config.size], name='real_images')
 
self.noise = tf.placeholder(tf.float32, [None, Config.noise_size], name='noise')
 
self.drop_rate = tf.placeholder('float')
 
self.train_step()
 
def generator_graph(self, noise, n_units, out_dim, alpha, reuse=False):
 
with tf.variable_scope('generator', reuse=reuse):
 
# Hidden layer
 
h1 = tf.layers.dense(noise, n_units, activation=None)
 
# Leaky ReLU
 
h1 = tf.maximum(alpha * h1, h1)
 
h1 = tf.layers.dropout(h1, rate=self.drop_rate)
 
# Logits and tanh output
 
logits = tf.layers.dense(h1, out_dim, activation=None)
 
out = tf.tanh(logits)
 
return out
 
@staticmethod
 
def discriminator_graph(image, n_units, alpha, reuse=False):
 
with tf.variable_scope('discriminator', reuse=reuse):
 
# Hidden layer
 
h1 = tf.layers.dense(image, n_units, activation=None)
 
# Leaky ReLU
 
h1 = tf.maximum(alpha * h1, h1)
 
logits = tf.layers.dense(h1, 1, activation=None)
 
# out = tf.sigmoid(logits)
 
return logits
 
def net(self):
 
# generator
 
fake_image = self.generator_graph(self.noise, Config.num_units, Config.size, Config.alpha)
 
# discriminator
 
real_logits = self.discriminator_graph(self.real_images, Config.num_units, Config.alpha)
 
fake_logits = self.discriminator_graph(fake_image, Config.num_units, Config.alpha, reuse=True)
 
# discriminator的loss
 
# 识别真实图片
 
d_loss_real = tf.reduce_mean(
 
tf.nn.sigmoid_cross_entropy_with_logits(logits=real_logits, labels=tf.ones_like(real_logits)) * (
 
1 - Config.smooth))
 
# 识别生成的图片
 
d_loss_fake = tf.reduce_mean(
 
tf.nn.sigmoid_cross_entropy_with_logits(logits=fake_logits, labels=tf.zeros_like(fake_logits)))
 
# 总体loss
 
d_loss = tf.add(d_loss_real, d_loss_fake)
 
# generator的loss
 
g_loss = tf.reduce_mean(
 
tf.nn.sigmoid_cross_entropy_with_logits(logits=fake_logits, labels=tf.ones_like(fake_logits)) * (
 
1 - Config.smooth))
 
net_vars = tf.trainable_variables()
 
# generator中的tensor
 
g_vars = [var for var in net_vars if var.name.startswith("generator")]
 
# discriminator中的tensor
 
d_vars = [var for var in net_vars if var.name.startswith("discriminator")]
 
# optimizer
 
dis_optimizer = tf.train.AdamOptimizer(Config.learning_rate).minimize(d_loss, var_list=d_vars)
 
gen_optimizer = tf.train.AdamOptimizer(Config.learning_rate).minimize(g_loss, var_list=g_vars)
 
return dis_optimizer, gen_optimizer, d_loss, g_loss
 
def train_step(self):
 
dis_optimizer, gen_optimizer, d_loss, g_loss = self.net()
 
print('Training & Evaluating......')
 
start_time = datetime.now()
 
sess = tf.Session()
 
sess.run(tf.global_variables_initializer())
 
for step in range(Config.steps):
 
real_image, _ = self.mnist.train.next_batch(Config.batch_size)
 
real_image = real_image * 2 - 1
 
# generator的输入噪声
 
batch_noise = np.random.uniform(-1, 1, size=(Config.batch_size, Config.noise_size))
 
sess.run(gen_optimizer, feed_dict={self.noise: batch_noise, self.drop_rate: Config.drop_rate})
 
sess.run(dis_optimizer, feed_dict={self.noise: batch_noise, self.real_images: real_image})
 
if step % Config.print_per_step == 0:
 
dis_loss = sess.run(d_loss, feed_dict={self.noise: batch_noise, self.real_images: real_image})
 
gen_loss = sess.run(g_loss, feed_dict={self.noise: batch_noise, self.drop_rate: 1.})
 
end_time = datetime.now()
 
time_diff = (end_time - start_time).seconds
 
msg = 'Step {:3}k Dis_Loss:{:6.2f}, Gen_Loss:{:6.2f}, Time_Usage:{:6.2f} mins.'
 
print(msg.format(int(step / 1000), dis_loss, gen_loss, time_diff / 60.))
 
self.gen_image(sess)
 
def gen_image(self, sess):
 
sample_noise = np.random.uniform(-1, 1, size=(25, Config.noise_size))
 
samples = sess.run(
 
self.generator_graph(self.noise, Config.num_units, Config.size, Config.alpha, reuse=True),
 
feed_dict={self.noise: sample_noise})
 
plt.figure(figsize=(8, 8), dpi=80)
 
for i in range(25):
 
img = samples[i]
 
plt.subplot(5, 5, i + 1)
 
plt.imshow(img.reshape((28, 28)), cmap='Greys_r')
 
plt.axis('off')
 
plt.show()
 
if __name__ == "__main__":
 
Gan()
 
Peace~~

目录
 
效果图
 
安装方法
 
使用方法
 

效果图
 
先上效果图
 

  
 
手写文章生成脚本，可模仿手写字体。
 
 
 
安装方法
 
 
 
1.下载脚本地址：https://github.com/DaviesGit/office_handwriting
 
2.安装handwriting_font_config文件夹内的所有字体。
 
3.打开word选择视图>宏>查看宏
 
 
4.填写宏的名称handwriting点击创建
 
 
5.将handwriting.vba文件中的内容复制到vbs编辑器中保存
 
 
6.右键Class Modules选择插入>Class Module
 
 
7.将FontConfig.vba中的内容复制到编辑器中保存，并将类名改为FontConfig
 
 
 
 
 
 
使用方法
 
 
 
1.打开查看宏的窗口，选择刚刚创建的宏，点击执行。
 
 
2.手动调整部分字体格式。
 
3.进行你需要的操作。
 
4.Good luck!
 
 

 
 
Java小白修炼手册


 在家上网课时老师会不会需要你拍照上传你的笔记呢？

 看完本文章让你告别手写笔记

 话不多说，先来看一下效果图

 


 是不是跟手写的一样

 接下来直接上代码，由于没有啥技术含量，无非就是给图片添加水印

 代码我就不再细说了

 有兴趣的朋友可以自己看一下源码

 
主函数和实现方法不在同一个class，注意！！

 主函数如下

 起始的bg.jpg和biji.txt和ss2.ttf文件我会上传在笔记生成文件里，包括源码
 
import come.MainFuncation.WorkWrite;
import java.awt.*;
import java.util.Scanner;
public class StartFunction {

    public static void main(String[] args) {
        System.out.print("请输入你的作业题目：");
        Scanner scanner = new Scanner(System.in);
        String fileName=scanner.next();
        System.out.println("开始生成笔记...");
        //启动
        WorkWrite workWrite = new WorkWrite();
        String backgroundImgPath="bg2.jpg"; //纸张图片地址
        String bijiPath="biji.txt";//你的笔记文本的地址
        String fontPath="ss2.ttf";//你的自定义字体文件的地址
        Font newFont=workWrite.newFont(fontPath,110);//自定义字体和大小，未设置大小则默认90
        String[] txt=workWrite.MarkContent(bijiPath);//笔记文本
        workWrite.setRowlen(120);//设置行间距，未设置默认为100
        Color color= new Color(Color.black.getRGB());//文字为黑色
        workWrite.addWaterMark(backgroundImgPath, fileName,txt,color,newFont);//生成
        System.out.println("完成");
    }
}
 
你可以自定义bg.jpg，即更换纸张图片
 将你网上白嫖来的笔记内容复制粘贴在biji.txt中
 字体文件我已经提供2种（代码里用的第二种手写体，个人感觉比另一种真实），不需要更改，你也可以网上下载个其他的手写体
 
实现方法代码：
 这部分代码是干活的
 
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import javax.imageio.ImageIO;
public class WorkWrite {

    private float fontSize=90;//字体大小
    private int rowlen=100;//行间距
    private int page=0;//页码
    /**
     * 绘制水印
     * @param split
     * @param markContentColor
     * @param font
     */
    public void addWaterMark(String backgroundImgPath, String resultImgPath, String[] split,Color markContentColor,Font font) {

        try {
            // 读取原图片信息
            File srcImgFile = new File(backgroundImgPath);//得到文件
            Image srcImg = ImageIO.read(srcImgFile);//文件转化为图片
            int srcImgWidth = srcImg.getWidth(null);//获取图片的宽
            int srcImgHeight = srcImg.getHeight(null);//获取图片的高
            BufferedImage bufImg = new BufferedImage(srcImgWidth, srcImgHeight, BufferedImage.TYPE_INT_RGB);
            Graphics2D g;
            g = bufImg.createGraphics();
            g.drawImage(srcImg, 0, 0, srcImgWidth, srcImgHeight, null);
            g.setColor(markContentColor); //设置水印颜色
            g.setFont(font);              //设置字体

            //内容起始坐标
            int x = 100;
            int y = 100;
            int maxWord= (int) (srcImgWidth/fontSize);//每行最多的字数
            for (int i=0;i<split.length;i++) {
                //字符串可能会出现��，导致出现一些空白，所以为了保险起见将这些字符替换成空字符串
                split[i]=split[i].replace("��","");
                //获取字符串的字数
                int collen=split[i].length();
                /*
                对每行的字符数进行规范
                 */

                if(collen>maxWord){//如果大于每行规定的字数
                    String substring = split[i].substring(0, maxWord);
                    g.drawString(substring, x, y);  //绘制从0截取到最大字数的字符串
                    y += rowlen;//换行
                    String more=split[i].substring(maxWord,collen);//截取多出来的字符串
                    g.drawString(more, x, y);//绘制多出来的字符串
                    y += rowlen;//换行
                }else {
                    //直接绘制
                    g.drawString(split[i], x, y);
                    y += rowlen;
                }
                //内容超出页面高度则分页
                if(y>=srcImgHeight-1.5*rowlen) {
                    g.dispose();
                    //导出已经写满的笔记
                    productImage(bufImg,resultImgPath,++page);
                    y=rowlen;
                    g = bufImg.createGraphics();
                    g.drawImage(srcImg, 0, 0, srcImgWidth, srcImgHeight, null);
                    g.setColor(markContentColor); //设置水印颜色
                    g.setFont(font);              //设置字体
                }
            }
            //将最后一张笔记生成
            g.dispose();
            productImage(bufImg,resultImgPath,++page);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 生产笔记图片
     * @param image
     * @param tarImgPath
     * @param page
     */
    public void productImage(BufferedImage image,String tarImgPath,int page){
        try {
            tarImgPath=tarImgPath+page+".jpg";
            FileOutputStream outImgStream = new FileOutputStream(tarImgPath);
            ImageIO.write(image, "jpg", outImgStream);
            outImgStream.flush();
            outImgStream.close();
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    /**
     * 获取笔记所有内容，存入字符串数组
     * @param path path
     * @return String[]
     */
    public String[] MarkContent(String path){
        StringBuilder builder = new StringBuilder();
        try {
            FileInputStream inputStream = new FileInputStream(path);
            byte[] bytes = new byte[1024];
            int temp;
            while ((temp=inputStream.read(bytes))!=-1){
                builder.append(new String(bytes,0,temp));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return builder.toString().split("。");
    }

    /**
     * 采用自定义手写字体，看起来更真实
     * @param path path
     * @param fontSize fontSize
     * @return Font
     */
    public Font newFont(String path,float fontSize){
        Font font = null;                     //水印字体
        try {
            font = Font.createFont(Font.TRUETYPE_FONT,new File(path));
            font=font.deriveFont(fontSize);
            setFontSize(fontSize);
        } catch (FontFormatException | IOException e) {
            e.printStackTrace();
        }
        return font;
    }
    public void setFontSize(float size){
        this.fontSize=size;
    }
    public void setRowlen(int rowlen){
        this.rowlen=rowlen;
    }
}
 
整体运行一下
 这是biji.txt的内容
 
 运行时输入作业名称
 
 回车运行
 
 运行完成后会在桌面生成一个output的文件夹
 

 里面的图片就是你的笔记，笔记名字就是你开始时输入的
 
 大功告成！
 相信老师应该看不出来，哈哈
 如果有疑问可以评论区留言，包回复
 如果有不足之处望指出，感谢阅读！！