|
|
//
|
|
|
// SWPosPointcut.c
|
|
|
// DrawTest
|
|
|
//
|
|
|
// Created by 王阳阳 on 2022/9/6.
|
|
|
//
|
|
|
|
|
|
#include "SWPosPointcut.h"
|
|
|
#include <QDebug>
|
|
|
|
|
|
#define MaxPoints 6000.f
|
|
|
#define MaxSegment 100.f
|
|
|
#define MaxWidthScale 1.5f
|
|
|
#define MinRadius 0.3f
|
|
|
#define MaxSteps 0.13f
|
|
|
#define MinShake 130
|
|
|
#define MaxShake 170
|
|
|
#define M_PI 3.14159265358979323846264338327950288f
|
|
|
#define RadianTodegrees(x) (x * 180.f / M_PI)
|
|
|
|
|
|
static SWPosPoint lastePos;
|
|
|
static SWLineSegment *curLeftLine = NULL;
|
|
|
static SWLineSegment *curRightLine = NULL;
|
|
|
static int pointStep = 0;
|
|
|
|
|
|
void SWPosRest(SWPosPoint pos) {
|
|
|
|
|
|
lastePos = pos;
|
|
|
pointStep = 0;
|
|
|
SWLineSegment *onSegment = curLeftLine;
|
|
|
if (curLeftLine != NULL) {
|
|
|
|
|
|
while (onSegment) {
|
|
|
|
|
|
SWLineSegment *tempSeg = (SWLineSegment *)onSegment->preSegment;
|
|
|
onSegment->preSegment = NULL;
|
|
|
free(onSegment);
|
|
|
if (tempSeg != NULL) {
|
|
|
|
|
|
onSegment = tempSeg;
|
|
|
|
|
|
} else {
|
|
|
|
|
|
onSegment = NULL;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
onSegment = curRightLine;
|
|
|
if (curRightLine != NULL) {
|
|
|
|
|
|
while (onSegment) {
|
|
|
|
|
|
SWLineSegment *tempSeg = (SWLineSegment *)onSegment->preSegment;
|
|
|
onSegment->preSegment = NULL;
|
|
|
free(onSegment);
|
|
|
if (tempSeg != NULL) {
|
|
|
|
|
|
onSegment = tempSeg;
|
|
|
|
|
|
} else {
|
|
|
|
|
|
onSegment = NULL;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
curLeftLine = NULL;
|
|
|
curRightLine = NULL;
|
|
|
|
|
|
}
|
|
|
|
|
|
SWPosRet SWGetTangentcurPoint(SWPosPoint prevPoint,SWPosPoint curPoint,
|
|
|
SWLineSegment leftLine,SWLineSegment rightLine,
|
|
|
int circle) {
|
|
|
|
|
|
double distance = GetPointDistance(prevPoint, curPoint);
|
|
|
double radiusDistance = (prevPoint.radius + curPoint.radius);
|
|
|
if ((distance < radiusDistance) || distance < 1) {
|
|
|
|
|
|
if (prevPoint.realPoint.x != lastePos.realPoint.x && prevPoint.realPoint.y != lastePos.realPoint.y){
|
|
|
|
|
|
double rads = SWBetweenLinesrads(lastePos.realPoint, prevPoint.realPoint,
|
|
|
curPoint.realPoint, prevPoint.realPoint);
|
|
|
double angle = RadianTodegrees(rads);
|
|
|
if (angle > 150) {
|
|
|
|
|
|
SWPosRet retPos;
|
|
|
retPos.prevLeftPoint = SWPointCutMake(0, 0);
|
|
|
retPos.prevLeftIntersectPoint = SWPointCutMake(0, 0);
|
|
|
retPos.prevRightPoint = SWPointCutMake(0, 0);
|
|
|
retPos.prevRightIntersectPoint = SWPointCutMake(0, 0);
|
|
|
retPos.curLeftPoint = SWPointCutMake(0, 0);
|
|
|
retPos.curRightPoint = SWPointCutMake(0, 0);
|
|
|
retPos.circlePoints.clear();
|
|
|
retPos.circleCount = 0;
|
|
|
retPos.status = SWPosRetFail;
|
|
|
return retPos;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
if (circle == 1 || pointStep == 0) {
|
|
|
|
|
|
return getCircleSegments(prevPoint, curPoint, leftLine, rightLine, distance,pointStep);
|
|
|
|
|
|
}
|
|
|
if (distance > fabs(prevPoint.radius - curPoint.radius)) {
|
|
|
|
|
|
SWPointcut pointFa= {0,0};//左侧切点
|
|
|
SWPointcut pointFa1 = {0,0};//右侧切点
|
|
|
SWPointcut pointFb = {0,0};//左侧切点
|
|
|
SWPointcut pointFb1 = {0,0};//右侧切点
|
|
|
|
|
|
double base = atan2(curPoint.realPoint.y - prevPoint.realPoint.y, curPoint.realPoint.x - prevPoint.realPoint.x);
|
|
|
double ang = acos((prevPoint.radius - curPoint.radius) / distance);
|
|
|
pointFa = GetMaleTangentPointValue(prevPoint, base + ang);
|
|
|
pointFb = GetMaleTangentPointValue(curPoint, base + ang);
|
|
|
pointFb1 = GetMaleTangentPointValue(curPoint, base - ang);
|
|
|
pointFa1 = GetMaleTangentPointValue(prevPoint, base - ang);
|
|
|
SWPointcut pointLeftIntersect = {0,0};//左侧切点
|
|
|
SWPointcut pointRightIntersect = {0,0};//右侧切点
|
|
|
if (leftLine.status == SWPosRetFail && rightLine.status == SWPosRetFail) {
|
|
|
|
|
|
pointStep++;
|
|
|
lastePos = prevPoint;
|
|
|
SWPosRet retPos1;
|
|
|
retPos1.prevLeftPoint = pointFa;//左侧切点
|
|
|
retPos1.prevLeftIntersectPoint = pointLeftIntersect;//左侧切点交点
|
|
|
retPos1.prevRightPoint = pointFa1;//右侧切点
|
|
|
retPos1.prevRightIntersectPoint = pointRightIntersect;//右侧切点交点
|
|
|
retPos1.curLeftPoint = pointFb;//当前点左侧切点
|
|
|
retPos1.curRightPoint = pointFb1;//当前点右侧切点
|
|
|
retPos1.circlePoints.clear();
|
|
|
retPos1.circleCount = 0;
|
|
|
retPos1.status = SWPosRetSuccess;//计算结果状态
|
|
|
return retPos1;
|
|
|
}
|
|
|
|
|
|
pointRightIntersect = SWgetEdgePoint(rightLine.startPoint,rightLine.endPoint,pointFa1,pointFb1,prevPoint.realPoint,0);
|
|
|
pointLeftIntersect = SWgetEdgePoint(leftLine.startPoint,leftLine.endPoint,pointFa,pointFb,prevPoint.realPoint,1);
|
|
|
if ((pointRightIntersect.x == 0 && pointRightIntersect.y ==0) || (pointLeftIntersect.x == 0 && pointLeftIntersect.y == 0)) {
|
|
|
|
|
|
return getCircleSegments(prevPoint, curPoint, leftLine, rightLine, distance,pointStep);
|
|
|
}
|
|
|
/**
|
|
|
* 处理切点极端情况（0，0）
|
|
|
*/
|
|
|
double lDistance = GetPointDistance(prevPoint,SWPosPointMake(pointLeftIntersect.x,pointLeftIntersect.y,0));
|
|
|
if (lDistance > prevPoint.radius*10) {
|
|
|
|
|
|
pointLeftIntersect = SWPointCutMake((leftLine.endPoint.x + pointFa.x)/2.f,(leftLine.endPoint.y + pointFa.y)/2.f);
|
|
|
}
|
|
|
double rDistance = GetPointDistance(prevPoint,SWPosPointMake(pointRightIntersect.x,pointRightIntersect.y,0));
|
|
|
if (rDistance > prevPoint.radius*10) {
|
|
|
|
|
|
pointRightIntersect = SWPointCutMake((rightLine.endPoint.x + pointFa1.x)/2.f,(rightLine.endPoint.y + pointFa1.y)/2.f);
|
|
|
}
|
|
|
SWPosRet retPos2;
|
|
|
retPos2.prevLeftPoint = pointFa;//左侧切点
|
|
|
retPos2.prevLeftIntersectPoint = pointLeftIntersect;//左侧切点交点
|
|
|
retPos2.prevRightPoint = pointFa1;//右侧切点
|
|
|
retPos2.prevRightIntersectPoint = pointRightIntersect;//右侧切点交点
|
|
|
retPos2.curLeftPoint = pointFb;//当前点左侧切点
|
|
|
retPos2.curRightPoint = pointFb1;//当前点右侧切点
|
|
|
retPos2.circlePoints.clear();
|
|
|
retPos2.circleCount = 0;
|
|
|
retPos2.status = SWPosRetSuccess;//计算结果状态
|
|
|
lastePos = prevPoint;
|
|
|
pointStep++;
|
|
|
return retPos2;
|
|
|
|
|
|
}
|
|
|
SWPosRet retPos;
|
|
|
retPos.prevLeftPoint = SWPointCutMake(0, 0);
|
|
|
retPos.prevLeftIntersectPoint = SWPointCutMake(0, 0);
|
|
|
retPos.prevRightPoint = SWPointCutMake(0, 0);
|
|
|
retPos.prevRightIntersectPoint = SWPointCutMake(0, 0);
|
|
|
retPos.curLeftPoint = SWPointCutMake(0, 0);
|
|
|
retPos.curRightPoint = SWPointCutMake(0, 0);
|
|
|
retPos.circlePoints.clear();
|
|
|
retPos.circleCount = 0;
|
|
|
retPos.status = SWPosRetFail;
|
|
|
return retPos;
|
|
|
}
|
|
|
|
|
|
SWPosRet getCircleSegments(SWPosPoint prevPoint,SWPosPoint curPoint,SWLineSegment leftLine,
|
|
|
SWLineSegment rightLine,double distance,int step) {
|
|
|
|
|
|
SWPointcut controlPoint = SWPointCutMake(prevPoint.realPoint.x, prevPoint.realPoint.y);
|
|
|
int segements = distance/0.2f;
|
|
|
if (segements < 5) {
|
|
|
|
|
|
segements = 5;
|
|
|
}
|
|
|
double preRadius = 0;
|
|
|
if (leftLine.status == SWPosRetSuccess && rightLine.status == SWPosRetSuccess) {
|
|
|
|
|
|
preRadius = GetPointDistance(SWPosPointMake(leftLine.endPoint.x, leftLine.endPoint.y, 0),
|
|
|
SWPosPointMake(rightLine.endPoint.x, rightLine.endPoint.y, 0))/2.f;
|
|
|
|
|
|
} else {
|
|
|
|
|
|
preRadius = prevPoint.radius;
|
|
|
}
|
|
|
double circleRadius = curPoint.radius - preRadius;
|
|
|
QList<SWCirclePoint> circleAry;
|
|
|
for (int i = 0; i < segements; i ++) {
|
|
|
|
|
|
if (i == 0) {
|
|
|
|
|
|
SWCirclePoint cPoint = SWCircleMake(SWPosPointMake(prevPoint.realPoint.x,
|
|
|
prevPoint.realPoint.y, preRadius));
|
|
|
circleAry.append(cPoint);
|
|
|
|
|
|
} else if (i == (segements - 1)) {
|
|
|
|
|
|
SWCirclePoint cPoint = SWCircleMake(SWPosPointMake(curPoint.realPoint.x,
|
|
|
curPoint.realPoint.y, preRadius + circleRadius));
|
|
|
circleAry.append(cPoint);
|
|
|
|
|
|
} else {
|
|
|
|
|
|
double t = (double)i/segements;
|
|
|
double x = pow(1 - t, 2) * prevPoint.realPoint.x + 2.0 * (1 - t) * t * controlPoint.x + t * t * curPoint.realPoint.x;
|
|
|
double y = pow(1 - t, 2) * prevPoint.realPoint.y + 2.0 * (1 - t) * t * controlPoint.y + t * t * curPoint.realPoint.y;
|
|
|
SWCirclePoint cPoint = SWCircleMake(SWPosPointMake(x, y, preRadius + circleRadius*t));
|
|
|
circleAry.append(cPoint);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
pointStep++;
|
|
|
SWPosRet retPos;
|
|
|
retPos.prevLeftPoint = SWPointCutMake(0, 0);//左侧切点
|
|
|
retPos.prevLeftIntersectPoint = SWPointCutMake(0, 0);//左侧切点交点
|
|
|
retPos.prevRightPoint = SWPointCutMake(0, 0);//右侧切点
|
|
|
retPos.prevRightIntersectPoint = SWPointCutMake(0, 0);//右侧切点交点
|
|
|
retPos.curLeftPoint = SWPointCutMake(0, 0);//当前点左侧切点
|
|
|
retPos.curRightPoint = SWPointCutMake(0, 0);//当前点右侧切点
|
|
|
retPos.circlePoints = circleAry;
|
|
|
retPos.circleCount = segements;
|
|
|
retPos.status = SWPosRetSuccess;//计算结果状态
|
|
|
return retPos;
|
|
|
}
|
|
|
|
|
|
|
|
|
QList<SWPosPoint> fillPoints(SWPosPoint prevPoint,SWPosPoint curPoint,double distance) {
|
|
|
|
|
|
SWPointcut controlPoint = SWPointCutMake(prevPoint.realPoint.x, prevPoint.realPoint.y);
|
|
|
int segements = distance/0.5f;
|
|
|
double preRadius = prevPoint.radius;
|
|
|
double circleRadius = curPoint.radius - preRadius;
|
|
|
QList<SWPosPoint> circleAry;
|
|
|
for (int i = 0; i < segements; i ++) {
|
|
|
|
|
|
double t = (double)i/segements;
|
|
|
double x = pow(1 - t, 2) * prevPoint.realPoint.x + 2.0 * (1 - t) * t * controlPoint.x + t * t * curPoint.realPoint.x;
|
|
|
double y = pow(1 - t, 2) * prevPoint.realPoint.y + 2.0 * (1 - t) * t * controlPoint.y + t * t * curPoint.realPoint.y;
|
|
|
SWPosPoint cPoint = SWPosPointMake(x, y, preRadius + circleRadius*t);
|
|
|
circleAry.append(cPoint);
|
|
|
}
|
|
|
return circleAry;
|
|
|
}
|
|
|
|
|
|
|
|
|
SWPosStatus IsPointInMatrix(SWPointcut p1 ,SWPointcut p2,SWPointcut p3 ,SWPointcut p4,SWPointcut p)
|
|
|
{
|
|
|
if (GetCross(p1,p2,p) * GetCross(p3,p4,p) >= 0 && GetCross(p2,p3,p) * GetCross(p4,p1,p) >= 0) {
|
|
|
|
|
|
return SWPosRetSuccess;
|
|
|
|
|
|
} else {
|
|
|
|
|
|
return SWPosRetFail;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
double GetCross(SWPointcut p1, SWPointcut p2,SWPointcut p)
|
|
|
{
|
|
|
return (p2.x - p1.x) * (p.y - p1.y) -(p.x - p1.x) * (p2.y - p1.y);
|
|
|
}
|
|
|
|
|
|
|
|
|
SWPointcut SWratioPoint(SWPointcut startPoint, SWPointcut endPoint, double ratio) {
|
|
|
|
|
|
SWPointcut ret = {0,0};
|
|
|
double x = endPoint.x - startPoint.x;
|
|
|
double y = endPoint.y - startPoint.y;
|
|
|
ret.x = x*ratio + startPoint.x;
|
|
|
ret.y = y*ratio + startPoint.y;
|
|
|
return ret;
|
|
|
|
|
|
}
|
|
|
|
|
|
SWPointcut SWrotatePoint(SWPointcut point, SWPointcut center, double angle) {
|
|
|
|
|
|
SWPointcut ret = {0,0};
|
|
|
double x = point.x - center.x;
|
|
|
double y = point.y - center.y;
|
|
|
ret.x = (x*cos(angle) - y*sin(angle)) + center.x;
|
|
|
ret.y = (x*sin(angle) + y*cos(angle)) + center.y;
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
SWPointcut GetMaleTangentPointValue(SWPosPoint point, double a)
|
|
|
{
|
|
|
SWPointcut ret = {0,0};
|
|
|
ret.x = (double) (point.realPoint.x + point.radius * cos(a));
|
|
|
ret.y = (double) (point.realPoint.y + point.radius * sin(a));
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
SWPointcut SWgetEdgePoint(SWPointcut a, SWPointcut b, SWPointcut c,SWPointcut d,SWPointcut e,int leftLine) {
|
|
|
|
|
|
|
|
|
double dx1 = a.x - b.x;
|
|
|
double dy1 = a.y - b.y;
|
|
|
double dx2 = d.x - c.x;
|
|
|
double dy2 = d.y - c.y;
|
|
|
SWPointcut edgePointf = {0,0};
|
|
|
SWPointcut pointf = {0,0};
|
|
|
if (dx1 == 0 && dx2 != 0) {//ab垂直x轴
|
|
|
double k2 = dy2 / dx2;//第二条直线斜率
|
|
|
double h2 = d.y - k2 * d.x;//第二条直线截距
|
|
|
//交点在a.x或者b.x
|
|
|
double x = a.x;
|
|
|
double y = k2 * x + h2;
|
|
|
pointf = SWPointCutMake(x,y);
|
|
|
if (isPointOnLine(x, y, a, b) == 1 && isPointOnLine(x, y, c, d) == 1) {//焦点在线段上
|
|
|
|
|
|
edgePointf = pointf;
|
|
|
}
|
|
|
} else if (dx1 != 0 && dx2 == 0) {//cd垂直x轴
|
|
|
double k1 = dy1 / dx1;//第一条直线斜率
|
|
|
double h1 = b.y - k1 * b.x;//第一条直线的截距
|
|
|
//交点在c.x或者d.x
|
|
|
double x = c.x;
|
|
|
double y = k1 * x + h1;
|
|
|
pointf = SWPointCutMake(x,y);
|
|
|
if (isPointOnLine(x, y, a, b) == 1 && isPointOnLine(x, y, c, d) == 1) {//焦点在线段上
|
|
|
edgePointf = pointf;
|
|
|
}
|
|
|
} else if (dx1 == 0 && dx2 == 0) {//ab cd都垂直x轴
|
|
|
//无交点
|
|
|
} else {
|
|
|
double k1 = dy1 / dx1;//第一条直线斜率
|
|
|
double h1 = b.y - k1 * b.x;//第一条直线的截距
|
|
|
double k2 = dy2 / dx2;//第二条直线斜率
|
|
|
double h2 = d.y - k2 * d.x;//第二条直线截距
|
|
|
if (k1 == k2) {//两直线平行
|
|
|
if (h1 == h2) {//重合
|
|
|
|
|
|
} else {//平行
|
|
|
|
|
|
}
|
|
|
} else {
|
|
|
double x = (h1 - h2) / (k2 - k1);
|
|
|
double y = k1 * x + h1;
|
|
|
pointf = SWPointCutMake(x,y);
|
|
|
if (isPointOnLine(x, y, a, b) == 1 && isPointOnLine(x, y, c, d) == 1) {//焦点在线段上
|
|
|
edgePointf = pointf;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (edgePointf.x > 0 && edgePointf.y > 0) {//有交点
|
|
|
return edgePointf;
|
|
|
} else {//无交点
|
|
|
// // 向量1的坐标:(x1,y1)，向量2的坐标:(x2,y2); 则
|
|
|
double tmpDegree = getAngle(dx1, dy1, dx2, dy2);
|
|
|
if ((pointf.x > 0 && pointf.y > 0) && tmpDegree >= 90 && tmpDegree < 180) {
|
|
|
|
|
|
return pointf;
|
|
|
} else if (tmpDegree == 180) {
|
|
|
|
|
|
return b;
|
|
|
} else {
|
|
|
|
|
|
//角度小于阈值进行补点操作
|
|
|
if (tmpDegree <= 90) {
|
|
|
|
|
|
return SWPointCutMake(0,0);
|
|
|
|
|
|
} else {
|
|
|
|
|
|
double rads = SWBetweenLinesrads(b, e, c, e);
|
|
|
double angle = RadianTodegrees(rads);
|
|
|
if (leftLine == 1) {
|
|
|
|
|
|
return SWrotatePoint(b,e,angle/2.f);
|
|
|
|
|
|
} else {
|
|
|
|
|
|
return SWrotatePoint(c,e,angle/2.f);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
int isPointOnLine(double x, double y, SWPointcut start, SWPointcut end) {
|
|
|
|
|
|
if (start.x <= end.x) {
|
|
|
if (x < start.x || x > end.x) return 0;
|
|
|
} else {
|
|
|
if (x < end.x || x > start.x) return 0;
|
|
|
}
|
|
|
if (start.y <= end.y) {
|
|
|
if (y < start.y || y > end.y) return 0;
|
|
|
} else {
|
|
|
if (y < end.y || y > start.y) return 0;
|
|
|
}
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
double getAngle(double x1, double y1, double x2, double y2) {
|
|
|
float value = (x1 * x2 + y1 * y2) / (hypot(x1, y1) * hypot(x2, y2)); // 余弦值
|
|
|
if(value < -1) {
|
|
|
|
|
|
value = -1;
|
|
|
}
|
|
|
if(value > 1) {
|
|
|
|
|
|
value = 1;
|
|
|
}
|
|
|
double angle = RadianTodegrees(acos(value)); // 角度
|
|
|
return angle;
|
|
|
}
|
|
|
|
|
|
|
|
|
SWPointcut getSamllAngleVertex(SWPointcut b, SWPointcut c,double cosAngle) {
|
|
|
double dx = c.x - b.x;
|
|
|
double dy = c.y - b.y;
|
|
|
// double disBC = Math.hypot(dx, dy);
|
|
|
// double betweenP = Math.cos((45f / 180f) * Math.PI) * disBC;
|
|
|
double ratio = (double) cos((cosAngle / 180.f) * M_PI);
|
|
|
SWPointcut betweenP = SWPointCutMake(b.x + dx * ratio, b.y + dy * ratio);
|
|
|
SWPointcut anglePointf = calcNewPoint(betweenP, b, (cosAngle / 180.f) * M_PI);
|
|
|
return anglePointf;
|
|
|
}
|
|
|
SWPointcut SWExtendPoint(SWPointcut a, SWPointcut b, SWPointcut c,SWPointcut d) {
|
|
|
|
|
|
SWPointcut point = {0,0};
|
|
|
double k1 = 0;
|
|
|
double k2 = 0;
|
|
|
int k1Vaild = 0;
|
|
|
int k2Vaild = 0;
|
|
|
double b1 = 0;
|
|
|
double b2 = 0;
|
|
|
if (b.x != a.x) {
|
|
|
|
|
|
k1 = (b.y - a.y)/(b.x - a.x);
|
|
|
k1Vaild = 1;
|
|
|
|
|
|
}
|
|
|
if (d.x != c.x) {
|
|
|
|
|
|
k2 = (d.y - c.y)/(d.x - c.x);
|
|
|
k2Vaild = 1;
|
|
|
|
|
|
}
|
|
|
if ( (k1Vaild == k2Vaild) && k1 == k2) {
|
|
|
|
|
|
return point;
|
|
|
|
|
|
}
|
|
|
if (k1Vaild == 1) {
|
|
|
|
|
|
b1 = (b.x*a.y - a.x*b.y)/(b.x - a.x);
|
|
|
}
|
|
|
if (k2Vaild == 1) {
|
|
|
|
|
|
b2 = (d.x*c.y - c.x*d.y)/(d.x - c.x);
|
|
|
|
|
|
}
|
|
|
|
|
|
if (k1Vaild == 0) {
|
|
|
|
|
|
point.x = a.x;
|
|
|
point.y = k2 * point.x + b2;
|
|
|
|
|
|
} else if (k2Vaild == 0) {
|
|
|
|
|
|
point.x = c.x;
|
|
|
point.y = k1 *point.x + b1;
|
|
|
|
|
|
} else if (k1 == 0) {
|
|
|
|
|
|
point.x = (a.y - b2)/k2;
|
|
|
point.y = a.y;
|
|
|
|
|
|
|
|
|
} else if (k2 == 0) {
|
|
|
|
|
|
point.x = (c.y - b1)/k1;
|
|
|
point.y = c.y;
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
point.x = (double)((b2 - b1) / (k1 - k2));
|
|
|
point.y = (double)((k2 * b1 - k1 * b2) / (k2 - k1));
|
|
|
|
|
|
}
|
|
|
return point;
|
|
|
|
|
|
}
|
|
|
|
|
|
double GetPointDistance(SWPosPoint start, SWPosPoint end) {
|
|
|
|
|
|
return sqrtf(pow((start.realPoint.x - end.realPoint.x), 2) + pow((start.realPoint.y - end.realPoint.y), 2))/1.f;
|
|
|
}
|
|
|
|
|
|
SWPointcut SWPointCutMake(double x,double y) {
|
|
|
|
|
|
SWPointcut pointCut = {x,y};
|
|
|
return pointCut;
|
|
|
}
|
|
|
|
|
|
SWPosPoint SWPosPointMake(double x,double y,double radius) {
|
|
|
|
|
|
SWPosPoint posPoint = {{x,y},radius};
|
|
|
return posPoint;
|
|
|
}
|
|
|
|
|
|
SWPointcut calcNewPoint(SWPointcut p, SWPointcut pCenter, double theta) {
|
|
|
double cosv = (double) cos(theta);
|
|
|
double sinv = (double) sin(theta);
|
|
|
|
|
|
// calc new point
|
|
|
double newX = (p.x - pCenter.x) * cosv - (p.y - pCenter.y) * sinv + pCenter.x;
|
|
|
double newY = (p.x - pCenter.x) * sinv + (p.y - pCenter.y) * cosv + pCenter.y;
|
|
|
return SWPointCutMake(newX, newY);
|
|
|
}
|
|
|
|
|
|
SWLineSegment SWLineMake(double x1,double y1,double x2, double y2) {
|
|
|
|
|
|
// SWLineSegment linePoint = {{x1,y1},{x2,y2},SWPosRetSuccess,NULL};
|
|
|
SWLineSegment linePoint;
|
|
|
// linePoint.startPoint = {x1,y1};
|
|
|
linePoint.startPoint.x = x1;
|
|
|
linePoint.startPoint.y = y1;
|
|
|
// linePoint.endPoint = {x2,y2};
|
|
|
linePoint.endPoint.x = x2;
|
|
|
linePoint.endPoint.y = y2;
|
|
|
linePoint.status = SWPosRetSuccess;
|
|
|
return linePoint;
|
|
|
}
|
|
|
|
|
|
|
|
|
SWLineSegment SWLineMakeZero(void) {
|
|
|
|
|
|
// SWLineSegment linePoint = {{0,0},{0,0},SWPosRetFail,NULL};
|
|
|
SWLineSegment linePoint;
|
|
|
// linePoint.startPoint = {0,0};
|
|
|
linePoint.startPoint.x = 0;
|
|
|
linePoint.startPoint.y = 0;
|
|
|
// linePoint.endPoint = {0,0};
|
|
|
linePoint.endPoint.x = 0;
|
|
|
linePoint.endPoint.y = 0;
|
|
|
linePoint.status = SWPosRetFail;
|
|
|
return linePoint;
|
|
|
}
|
|
|
|
|
|
|
|
|
double SWBetweenLinesrads(SWPointcut line1Start, SWPointcut line1End, SWPointcut line2Start, SWPointcut line2End) {
|
|
|
|
|
|
double a = line1End.x - line1Start.x;
|
|
|
double b = line1End.y - line1Start.y;
|
|
|
double c = line2End.x - line2Start.x;
|
|
|
double d = line2End.y - line2Start.y;
|
|
|
float value = ((a*c) + (b*d)) / ((sqrt(a*a + b*b)) * (sqrt(c*c + d*d)));
|
|
|
if(value < -1) {
|
|
|
|
|
|
value = -1;
|
|
|
}
|
|
|
if(value > 1) {
|
|
|
|
|
|
value = 1;
|
|
|
}
|
|
|
float rads = acos(value);
|
|
|
return rads;
|
|
|
}
|
|
|
|
|
|
double CalculatePointradius(double speed,double prevPointradius,
|
|
|
double radius,double force ,double maxForce,
|
|
|
double stressSpl,int forceEnable,
|
|
|
double distance) {
|
|
|
|
|
|
if (speed > MaxPoints) {
|
|
|
|
|
|
speed = MaxPoints;
|
|
|
}
|
|
|
if (forceEnable == 1) {
|
|
|
|
|
|
double forceScale = force/maxForce;
|
|
|
forceScale = forceScale * (1 + stressSpl);
|
|
|
double newRadius = radius*forceScale;
|
|
|
double dropSize = newRadius - prevPointradius ;
|
|
|
if (dropSize > prevPointradius *MaxSteps) {
|
|
|
|
|
|
dropSize = prevPointradius *MaxSteps;
|
|
|
|
|
|
}
|
|
|
if (dropSize < - prevPointradius *MaxSteps) {
|
|
|
|
|
|
dropSize = - prevPointradius *MaxSteps;
|
|
|
}
|
|
|
newRadius = prevPointradius + dropSize;
|
|
|
newRadius = newRadius > MaxWidthScale*radius ? MaxWidthScale*radius : newRadius;
|
|
|
if(newRadius < 0.7f) {
|
|
|
|
|
|
newRadius = 0.7f;
|
|
|
}
|
|
|
return newRadius;
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
double speedScale = MaxPoints/MaxSegment;
|
|
|
double fragments = speed/speedScale;
|
|
|
double radiusScale = fragments/MaxSegment;
|
|
|
double newRadius = radius - radius*radiusScale;
|
|
|
double dropSize = prevPointradius - newRadius;
|
|
|
if (dropSize > prevPointradius *MaxSteps) {
|
|
|
|
|
|
dropSize = prevPointradius *MaxSteps;
|
|
|
|
|
|
}
|
|
|
if (dropSize < - prevPointradius *MaxSteps) {
|
|
|
|
|
|
dropSize = - prevPointradius *MaxSteps;
|
|
|
}
|
|
|
newRadius = prevPointradius - dropSize;
|
|
|
newRadius = newRadius < MinRadius*radius ? MinRadius*radius : newRadius;
|
|
|
if(newRadius < 0.7f) {
|
|
|
|
|
|
newRadius = 0.7f;
|
|
|
}
|
|
|
return newRadius;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
SWPosPoint *CalculateStroke(SWPosPoint posAry[],int length,double preRadius) {
|
|
|
|
|
|
for (int k = 0; k < length; k ++) {
|
|
|
|
|
|
SWPosPoint pos = posAry[k];
|
|
|
double pointRadius = preRadius /(length - 1);
|
|
|
pos.radius = preRadius - pointRadius*k;
|
|
|
if (pos.radius <= 0.4) {
|
|
|
|
|
|
pos.radius = 0.4f;
|
|
|
}
|
|
|
posAry[k] = pos;
|
|
|
}
|
|
|
return posAry;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
SWPosStatus CalculateShake(SWPosPoint prePoint,SWPosPoint curPoint,SWPosPoint nextPoint) {
|
|
|
|
|
|
double distance = GetPointDistance(curPoint, nextPoint);
|
|
|
double rads = SWBetweenLinesrads(SWPointCutMake(prePoint.realPoint.x, prePoint.realPoint.y),
|
|
|
SWPointCutMake(curPoint.realPoint.x, curPoint.realPoint.y),
|
|
|
SWPointCutMake(nextPoint.realPoint.x, nextPoint.realPoint.y),
|
|
|
SWPointCutMake(curPoint.realPoint.x, curPoint.realPoint.y));
|
|
|
double angle = RadianTodegrees(rads);
|
|
|
if (angle > MinShake && angle < MaxShake && distance < 1) {
|
|
|
|
|
|
return SWPosRetFail;
|
|
|
}
|
|
|
return SWPosRetFail;
|
|
|
}
|
|
|
|
|
|
|
|
|
SWPosStatus SWPosEqualToPos(SWPosPoint pos1,SWPosPoint pos2) {
|
|
|
|
|
|
if (pos1.realPoint.x == pos2.realPoint.x && pos1.realPoint.y == pos2.realPoint.y) {
|
|
|
|
|
|
return SWPosRetSuccess;
|
|
|
|
|
|
} else {
|
|
|
|
|
|
return SWPosRetFail;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
SWPosPoint SWPosPointMakeZero(void) {
|
|
|
|
|
|
return SWPosPointMake(0, 0, 0);
|
|
|
}
|
|
|
|
|
|
SWPointcut ExPandLine(SWPointcut pt1,SWPointcut pt2,double nLen)
|
|
|
{
|
|
|
SWPointcut OutPt = SWPointCutMake(0, 0);
|
|
|
if (pt1.x - pt2.x == 0)
|
|
|
{
|
|
|
OutPt.x = pt1.x;
|
|
|
if (pt1.y - pt2.y > 0)
|
|
|
{
|
|
|
OutPt.y = pt2.y - nLen;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
OutPt.y = pt2.y + nLen;
|
|
|
}
|
|
|
}
|
|
|
else if (pt1.y - pt2.y == 0)
|
|
|
{
|
|
|
OutPt.y = pt1.y;
|
|
|
if (pt1.x - pt2.x > 0)
|
|
|
{
|
|
|
OutPt.x = pt2.x - nLen;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
OutPt.x = pt2.x + nLen;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
double k = 0.0;
|
|
|
double b = 0.0;
|
|
|
k = (pt1.y - pt2.y)/(pt1.x-pt2.x);
|
|
|
b = pt1.y - k * pt1.x;
|
|
|
double zoom = 0.0;
|
|
|
zoom = nLen/sqrt((pt2.x-pt1.x)*(pt2.x-pt1.x)+(pt2.y-pt1.y)*(pt2.y-pt1.y));
|
|
|
|
|
|
if(k > 0)
|
|
|
{
|
|
|
if (pt1.x-pt2.x > 0)
|
|
|
{
|
|
|
OutPt.x = pt2.x - zoom * (pt1.x-pt2.x);
|
|
|
OutPt.y = k*OutPt.x + b;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
OutPt.x = pt2.x + zoom * (pt2.x-pt1.x);
|
|
|
OutPt.y = k*OutPt.x + b;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (pt1.x-pt2.x > 0)
|
|
|
{
|
|
|
OutPt.x = pt2.x - zoom * (pt1.x-pt2.x) ;
|
|
|
OutPt.y = k*OutPt.x + b;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
OutPt.x = pt2.x + zoom * (pt2.x - pt1.x);
|
|
|
OutPt.y = k*OutPt.x + b;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return OutPt;
|
|
|
}
|
|
|
|
|
|
SWCirclePoint SWCircleMake(SWPosPoint center) {
|
|
|
|
|
|
double radian = 2*M_PI/4.f;
|
|
|
double cosa = cos(radian);
|
|
|
double sina = sin(radian);
|
|
|
double h = center.radius*(4*(1 - cos(radian/2.f)))/(3*sin(radian/2.f));
|
|
|
|
|
|
SWPointcut pointA = SWPointCutMake(center.radius + center.realPoint.x, center.realPoint.y);
|
|
|
SWPointcut pointB = SWPointCutMake(center.radius + center.realPoint.x, center.realPoint.y - h);
|
|
|
SWPointcut pointC = SWPointCutMake(center.radius*cosa + h*sina + center.realPoint.x, center.realPoint.y - (center.radius*sina - h*cosa));
|
|
|
SWPointcut pointD = SWPointCutMake(center.realPoint.x,center.realPoint.y - center.radius);
|
|
|
|
|
|
SWPointcut pointE = SWPointCutMake(center.realPoint.x - (center.radius*cosa + h*sina), pointC.y);
|
|
|
SWPointcut pointF = SWPointCutMake(center.realPoint.x - center.radius, pointB.y);
|
|
|
SWPointcut pointG = SWPointCutMake(center.realPoint.x - center.radius, center.realPoint.y);
|
|
|
|
|
|
SWPointcut pointH = SWPointCutMake(pointF.x, center.realPoint.y + h);
|
|
|
SWPointcut pointI = SWPointCutMake(pointE.x, center.realPoint.y + (center.radius*sina - h*cosa));
|
|
|
SWPointcut pointJ = SWPointCutMake(center.realPoint.x, center.realPoint.y + center.radius);
|
|
|
|
|
|
SWPointcut pointK = SWPointCutMake(pointC.x, pointI.y);
|
|
|
SWPointcut pointL = SWPointCutMake(pointB.x, pointH.y);
|
|
|
SWPointcut pointM = SWPointCutMake(center.radius + center.realPoint.x, center.realPoint.y);
|
|
|
|
|
|
SWCirclePoint cPoint = {pointA,pointB,pointC,pointD,pointE,pointF,pointG,pointH,pointI,pointJ,pointK,pointL,pointM};
|
|
|
|
|
|
return cPoint;
|
|
|
}
|
