由于项目中有实现毛笔的效果的要求，所以在网上找了一个Android的demo，然后将其改成了Java FX版本的，算法来自网上某个Android的demo(不好意思忘记了原来的url，如果原版作者有意见可以联系我)。
package brush;
import javafx.scene.paint.Color;
/**
* @des 笔的设置，但是有些笔的设置最好不要放在这里，不要笔的颜色和宽度
*/
public interface IPenConfig {
/**
* 清除画布
*/
int STROKE_TYPE_ERASER = 0;
/**
* 钢笔
*/
int STROKE_TYPE_PEN = 1;// 钢笔
/**
* 毛笔
*/
int STROKE_TYPE_BRUSH = 2;// 毛笔
//设置笔的宽度
int PEN_WIDTH=60;
//笔的颜色
Color PEN_CORLOUR= Color.valueOf("#FF4081");
//这个控制笔锋的控制值
float DIS_VEL_CAL_FACTOR = 0.02f;
//手指在移动的控制笔的变化率 这个值越大，线条的粗细越加明显
//float WIDTH_THRES_MAX = 0.6f;
float WIDTH_THRES_MAX = 10f;
//绘制计算的次数，数值越小计算的次数越多，需要折中
int STEPFACTOR = 10;
}
package brush;
/**
* @des 每个点的控制，关心三个因素：笔的宽度，坐标,透明数值
*/
public class ControllerPoint {
public float x;
public float y;
public float width;
public int alpha = 255;
public ControllerPoint() {
}
public ControllerPoint(float x, float y) {
this.x = x;
this.y = y;
}
public void set(float x, float y, float w) {
this.x = x;
this.y = y;
this.width = w;
}
public void set(ControllerPoint point) {
this.x = point.x;
this.y = point.y;
this.width = point.width;
}
public String toString() {
String str = "X = " + x + "; Y = " + y + "; W = " + width;
return str;
}
}
package brush;
/**
* @des 对点的位置和宽度控制的bezier曲线，主要是两个点，都包含了宽度和点的坐标
*/
public class Bezier {
//控制点的，
private ControllerPoint mControl = new ControllerPoint();
//距离
private ControllerPoint mDestination = new ControllerPoint();
//下一个需要控制点
private ControllerPoint mNextControl = new ControllerPoint();
//资源的点
private ControllerPoint mSource = new ControllerPoint();
public Bezier() {
}
/**
* 初始化两个点，
* @param last 最后的点的信息
* @param cur 当前点的信息,当前点的信息，当前点的是根据事件获得，同时这个当前点的宽度是经过计算的得出的
*/
public void init(ControllerPoint last, ControllerPoint cur)
{
init(last.x, last.y, last.width, cur.x, cur.y, cur.width);
}
public void init(float lastx, float lasty, float lastWidth, float x, float y, float width)
{
//资源点设置，最后的点的为资源点
mSource.set(lastx, lasty, lastWidth);
float xmid = getMid(lastx, x);
float ymid = getMid(lasty, y);
float wmid = getMid(lastWidth, width);
//距离点为平均点
mDestination.set(xmid, ymid, wmid);
//控制点为当前的距离点
mControl.set(getMid(lastx,xmid),getMid(lasty,ymid),getMid(lastWidth,wmid));
//下个控制点为当前点
mNextControl.set(x, y, width);
}
public void addNode(ControllerPoint cur){
addNode(cur.x, cur.y, cur.width);
}
/**
* 替换就的点，原来的距离点变换为资源点，控制点变为原来的下一个控制点，距离点取原来控制点的和新的的一半
* 下个控制点为新的点
* @param x 新的点的坐标
* @param y 新的点的坐标
* @param width
*/
public void addNode(float x, float y, float width){
mSource.set(mDestination);
mControl.set(mNextControl);
mDestination.set(getMid(mNextControl.x, x), getMid(mNextControl.y, y), getMid(mNextControl.width, width));
mNextControl.set(x, y, width);
}
/**
* 结合手指抬起来的动作，告诉现在的曲线控制点也必须变化，其实在这里也不需要结合着up事件使用
* 因为在down的事件中，所有点都会被重置，然后设置这个没有多少意义，但是可以改变下个事件的朝向改变
* 先留着，因为后面如果需要控制整个颜色的改变的话，我的依靠这个方法，还有按压的时间的变化
*/
public void end() {
mSource.set(mDestination);
float x = getMid(mNextControl.x, mSource.x);
float y = getMid(mNextControl.y, mSource.y);
float w = getMid(mNextControl.width, mSource.width);
mControl.set(x, y, w);
mDestination.set(mNextControl);
}
/**
*
* @param t 控制点
* @return
*/
public ControllerPoint getPoint(double t){
float x = (float)getX(t);
float y = (float)getY(t);
float w = (float)getW(t);
ControllerPoint point = new ControllerPoint();
point.set(x,y,w);
return point;
}
/**
* 三阶曲线的控制点
* @param p0
* @param p1
* @param p2
* @param t
* @return
*/
private double getValue(double p0, double p1, double p2, double t){
double A = p2 - 2 * p1 + p0;
double B = 2 * (p1 - p0);
double C = p0;
return A * t * t + B * t + C;
}
private double getX(double t) {
return getValue(mSource.x, mControl.x, mDestination.x, t);
}
private double getY(double t) {
return getValue(mSource.y, mControl.y, mDestination.y, t);
}
private double getW(double t){
return getWidth(mSource.width, mDestination.width, t);
}
/**
*
* @param x1 一个点的x
* @param x2 一个点的x
* @return
*/
private float getMid(float x1, float x2) {
return (float)((x1 + x2) / 2.0);
}
private double getWidth(double w0, double w1, double t){
return w0 + (w1 - w0) * t;
}
}
package brush;
import java.util.ArrayList;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.Pane;
import javafx.scene.shape.Ellipse;
public class BasePenExtend {
public ArrayList mHWPointList = new ArrayList<>();
public ArrayList mPointList = new ArrayList();
public ControllerPoint mLastPoint = new ControllerPoint(0, 0);
//笔的宽度信息
public double mBaseWidth;
public double mLastVel;
public double mLastWidth;
public Bezier mBezier = new Bezier();
protected ControllerPoint mCurPoint;
public BasePenExtend() {
}
public void setPaint(double width) {
mBaseWidth = width;
}
public void draw(Pane pane) {
//点的集合少 不去绘制
if (mHWPointList == null || mHWPointList.size() < 1)
return;
//当控制点的集合很少的时候，需要画个小圆，但是需要算法
if (mHWPointList.size() < 2) {
ControllerPoint point = mHWPointList.get(0);
//由于此问题在算法上还没有实现，所以暂时不给他画圆圈
//canvas.drawCircle(point.x, point.y, point.width, mPaint);
} else {
mCurPoint = mHWPointList.get(0);
drawNeetToDo(pane);
}
}
public boolean onTouchEvent(int mouseType,MouseEvent event, Pane canvas) {
// event会被下一次事件重用，这里必须生成新的，否则会有问题
switch (mouseType) {
case 0:
onDown(event);
return true;
case 1:
onMove(event);
return true;
case 2:
onUp(event, canvas);
return true;
default:
break;
}
return false;
}
/**
* 按下的事件
*
* @param mElement
*/
public void onDown(MouseEvent mElement) {
mPointList.clear();
//如果在brush字体这里接受到down的事件，把下面的这个集合清空的话，那么绘制的内容会发生改变
//不清空的话，也不可能
mHWPointList.clear();
//记录down的控制点的信息
ControllerPoint curPoint = new ControllerPoint((float)mElement.getSceneX(), (float)mElement.getSceneY());
//如果用笔画的画我的屏幕，记录他宽度的和压力值的乘，但是哇，
/*if (mElement.tooltype == MotionEvent.TOOL_TYPE_STYLUS) {
mLastWidth = mElement.pressure * mBaseWidth;
} else {*/
//如果是手指画的，我们取他的0.8
mLastWidth = 0.8 * mBaseWidth;
/* }*/
//down下的点的宽度
curPoint.width = (float) mLastWidth;
mLastVel = 0;
mPointList.add(curPoint);
//记录当前的点
mLastPoint = curPoint;
}
/**
* 手指移动的事件
*
* @param mElement
*/
public void onMove(MouseEvent mElement) {
ControllerPoint curPoint = new ControllerPoint((float)mElement.getSceneX(), (float)mElement.getSceneY());
double deltaX = curPoint.x - mLastPoint.x;
double deltaY = curPoint.y - mLastPoint.y;
//deltaX和deltay平方和的二次方根 想象一个例子 1+1的平方根为1.4 (x²+y²)开根号
//同理，当滑动的越快的话，deltaX+deltaY的值越大，这个越大的话，curDis也越大
double curDis = Math.hypot(deltaX, deltaY);
//我们求出的这个值越小，画的点或者是绘制椭圆形越多，这个值越大的话，绘制的越少，笔就越细，宽度越小
double curVel = curDis * IPenConfig.DIS_VEL_CAL_FACTOR;
double curWidth;
//点的集合少，我们得必须改变宽度,每次点击的down的时候，这个事件
if (mPointList.size() < 2) {
/*if (mElement.tooltype == MotionEvent.TOOL_TYPE_STYLUS) {
curWidth = mElement.pressure * mBaseWidth;
} else {*/
curWidth = calcNewWidth(curVel, mLastVel, curDis, 1.5,
mLastWidth);
/* }*/
curPoint.width = (float) curWidth;
mBezier.init(mLastPoint, curPoint);
} else {
mLastVel = curVel;
/* if (mElement.tooltype == MotionEvent.TOOL_TYPE_STYLUS) {
curWidth = mElement.pressure * mBaseWidth;
} else {*/
//由于我们手机是触屏的手机，滑动的速度也不慢，所以，一般会走到这里来
//阐明一点，当滑动的速度很快的时候，这个值就越小，越慢就越大，依靠着mlastWidth不断的变换
curWidth = calcNewWidth(curVel, mLastVel, curDis, 1.5,
mLastWidth);
/*}*/
curPoint.width = (float) curWidth;
mBezier.addNode(curPoint);
}
//每次移动的话，这里赋值新的值
mLastWidth = curWidth;
mPointList.add(curPoint);
moveNeetToDo(curDis);
mLastPoint = curPoint;
}
/**
* 手指抬起来的事件
*
* @param mElement
* @param canvas
*/
public void onUp(MouseEvent mElement, Pane canvas) {
mCurPoint = new ControllerPoint((float)mElement.getSceneX(), (float)mElement.getSceneY());
double deltaX = mCurPoint.x - mLastPoint.x;
double deltaY = mCurPoint.y - mLastPoint.y;
double curDis = Math.hypot(deltaX, deltaY);
//如果用笔画的画我的屏幕，记录他宽度的和压力值的乘，但是哇，这个是不会变的
/* if (mElement.tooltype == MotionEvent.TOOL_TYPE_STYLUS) {
mCurPoint.width = (float) (mElement.pressure * mBaseWidth);
} else {*/
mCurPoint.width = 0;
/* }*/
mPointList.add(mCurPoint);
mBezier.addNode(mCurPoint);
int steps = 1 + (int) curDis / IPenConfig.STEPFACTOR;
double step = 1.0 / steps;
for (double t = 0; t < 1.0; t += step) {
ControllerPoint point = mBezier.getPoint(t);
mHWPointList.add(point);
}
//
mBezier.end();
for (double t = 0; t < 1.0; t += step) {
ControllerPoint point = mBezier.getPoint(t);
mHWPointList.add(point);
}
// 手指up 我画到纸上上
draw(canvas);
//每次抬起手来，就把集合清空，在水彩笔的那个地方，如果啊，我说如果不清空的话，每次抬起手来，
// 在onDown下去的话，最近画的线的透明度有改变，所以这里clear下线的集合
clear();
}
/**
* @param curVel
* @param lastVel
* @param curDis
* @param factor
* @param lastWidth
* @return
*/
public double calcNewWidth(double curVel, double lastVel, double curDis,
double factor, double lastWidth) {
double calVel = curVel * 0.6 + lastVel * (1 - 0.6);
//返回指定数字的自然对数
//手指滑动的越快，这个值越小，为负数
double vfac = Math.log(factor * 2.0f) * (-calVel);
//此方法返回值e，其中e是自然对数的基数。
//Math.exp(vfac) 变化范围为0 到1 当手指没有滑动的时候 这个值为1 当滑动很快的时候无线趋近于0
//在次说明下，当手指抬起来，这个值会变大，这也就说明，抬起手太慢的话，笔锋效果不太明显
//这就说明为什么笔锋的效果不太明显
double calWidth = mBaseWidth * Math.exp(vfac);
//滑动的速度越快的话，mMoveThres也越大
double mMoveThres = curDis * 0.01f;
//对之值最大的地方进行控制
if (mMoveThres > IPenConfig.WIDTH_THRES_MAX) {
mMoveThres = IPenConfig.WIDTH_THRES_MAX;
}
// TODO: 2018/2/24 以下的方法 可以删除掉 原因是抽取了一下 ，本来不应该在这里的出现的 不好意思
// //滑动越慢的情况下，得到的calWidth 和上面的calwidth 相差的值不一样
//
// //滑动的越快的话，第一个判断会走
// if (Math.abs(calWidth - mBaseWidth) / mBaseWidth > mMoveThres) {
// if (calWidth > mBaseWidth) {
// calWidth = mBaseWidth * (1 + mMoveThres);
// } else {
// calWidth = mBaseWidth * (1 - mMoveThres);
// }
// //滑动的越慢的话，第二个判断会走 基本上在屏幕上手指基本上没有走动的时候 ，就会走这个方法
// } else if (Math.abs(calWidth - lastWidth) / lastWidth > mMoveThres) {
// if (calWidth > lastWidth) {
// calWidth = lastWidth * (1 + mMoveThres);
// } else {
// calWidth = lastWidth * (1 - mMoveThres);
// }
// }
return calWidth;
}
/**
* event.getPressure(); //LCD可以感应出用户的手指压力，当然具体的级别由驱动和物理硬件决定的,我的手机上为1
*
* @param motionEvent
* @return
*/
/* public MotionElement createMotionElement(MotionEvent motionEvent) {
MotionElement motionElement = new MotionElement(motionEvent.getX(), motionEvent.getY(),
motionEvent.getPressure(), motionEvent.getToolType(0));
return motionElement;
}*/
public void clear() {
mPointList.clear();
mHWPointList.clear();
}
/**
* 当现在的点和触摸点的位置在一起的时候不用去绘制
* 但是这里也可以优化，当一直处于onDown事件的时候，其实这个方法一只在走
*
* @param canvas
* @param point
* @param paint
*/
// TODO: 2017/10/18 这里可以优化 当一直处于onDown事件的时候，其实这个方法一直在走，优化的点是，处于down事件，这里不需要走
protected void drawToPoint(Pane canvas, ControllerPoint point) {
if ((mCurPoint.x == point.x) && (mCurPoint.y == point.y)) {
return;
}
//水彩笔的效果和钢笔的不太一样，交给自己去实现
doNeetToDo(canvas, point);
}
/**
* 判断笔是否为空 节约性能，每次切换笔的时候就不用重复设置了
*
* @return
*/
/* public boolean isNull() {
return mPaint == null;
}*/
protected void drawNeetToDo(Pane pane) {
for (int i = 1; i < mHWPointList.size(); i++) {
ControllerPoint point = mHWPointList.get(i);
drawToPoint(pane, point);
mCurPoint = point;
}
}
protected void moveNeetToDo(double curDis) {
int steps = 1 + (int) curDis / IPenConfig.STEPFACTOR;
double step = 1.0 / steps;
for (double t = 0; t < 1.0; t += step) {
ControllerPoint point = mBezier.getPoint(t);
mHWPointList.add(point);
}
}
protected void doNeetToDo(Pane canvas, ControllerPoint point) {
drawLine(canvas, mCurPoint.x, mCurPoint.y, mCurPoint.width, point.x,
point.y, point.width);
}
/**
* 其实这里才是关键的地方，通过画布画椭圆，每一个点都是一个椭圆，这个椭圆的所有细节，逐渐构建出一个完美的笔尖
* 和笔锋的效果,我觉得在这里需要大量的测试，其实就对低端手机进行排查，看我们绘制的笔的宽度是多少，绘制多少个椭圆
* 然后在低端手机上不会那么卡，当然你哪一个N年前的手机给我，那也的卡，只不过需要适中的范围里面
*
* @param canvas
* @param x0
* @param y0
* @param w0
* @param x1
* @param y1
* @param w1
* @param paint
*/
private void drawLine(Pane canvas, double x0, double y0, double w0, double x1, double y1, double w1) {
//求两个数字的平方根 x的平方+y的平方在开方记得X的平方+y的平方=1，这就是一个园
double curDis = Math.hypot(x0 - x1, y0 - y1);
int steps = 1;
if (mBaseWidth < 6) {
steps = 1 + (int) (curDis / 2);
} else if (mBaseWidth > 60) {
steps = 1 + (int) (curDis / 4);
} else {
steps = 1 + (int) (curDis / 3);
}
double deltaX = (x1 - x0) / steps;
double deltaY = (y1 - y0) / steps;
double deltaW = (w1 - w0) / steps;
double x = x0;
double y = y0;
double w = w0;
for (int i = 0; i < steps; i++) {
//都是用于表示坐标系中的一块矩形区域，并可以对其做一些简单操作
//精度不一样。Rect是使用int类型作为数值，RectF是使用float类型作为数值。
// Rect rect = new Rect();
// RectF oval = new RectF();
Ellipse ellipse = new Ellipse();
float centerX=((float) (x - w / 4.0f)+(float) (x + w / 4.0f))/2;
float centerY=((float) (y - w / 2.0f)+(float) (y + w / 2.0f))/2;
ellipse.setCenterX(centerX);
ellipse.setCenterY(centerY);
ellipse.setRadiusX((Math.abs((float) (x - w / 4.0f)-(float) (x + w / 4.0f)))/2);
ellipse.setRadiusY(Math.abs(((float) (y - w / 2.0f)-(float) (y + w / 2.0f))/2));
/* oval.set((float) (x - w / 4.0f), (float) (y - w / 2.0f), (float) (x + w / 4.0f), (float) (y + w / 2.0f));
// oval.set((float)(x+w/4.0f), (float)(y+w/4.0f), (float)(x-w/4.0f), (float)(y-w/4.0f));
*/ //最基本的实现，通过点控制线，绘制椭圆
canvas.getChildren().add(ellipse);
x += deltaX;
y += deltaY;
w += deltaW;
}
}
}
/**
*
*/
package brush;
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.layout.Pane;
import javafx.stage.Stage;
/**
* @author gj
*
* 2018年6月6日
*/
public class Test extends Application {
/* (non-Javadoc)
* @see javafx.application.Application#start(javafx.stage.Stage)
*/
@Override
public void start(Stage arg0) throws Exception {
// TODO Auto-generated method stub
Pane pane = new Pane();
pane.setPrefSize(800, 900);
BasePenExtend basePenExtend=new BasePenExtend();
basePenExtend.setPaint(50);
basePenExtend.draw(pane);
pane.setOnMousePressed(e->{
basePenExtend.onTouchEvent(0, e, pane);
});
pane.setOnMouseDragged(e->{
basePenExtend.onTouchEvent(1, e, pane);
basePenExtend.draw(pane);
});
pane.setOnMouseReleased(e->{
basePenExtend.onTouchEvent(2, e, pane);
});
arg0.setScene(new Scene(pane));
arg0.show();
}
public static void main(String[] args) {
launch(args);
}
}
