drawing smooth curves methods needed Â using -'iphone,objective-c,ios,ipad,bezier-curve'

Like everyone before has asked, how do you smooth a set of points in an iOS drawing app WHILE MOVING? I have tried UIBezierpaths but all I get are jagged ends where they intersect, when I just shift the points 1,2,3,4 - 2,3,4,5. I have heard of spline curves and all the other types. I am quite new to iPhone programming and do not understand how to program it in my quartz drawing app. A solid example would be greatly appreciated, I have spent weeks running in circles and I can never seem to find any iOS code for this task. Most of the posts just link to a java simulation or pages on wikipedia about curve fitting which does nothing for me. Also I do not want to switch to openGL ES. I hope someone can finally provide code to answer this circulating question.

Thank You, Happy New Year!!!

.....................................................................................................................................................................

This was my code for the UIBezierPath which left edges at intersection///

UPDATED TO AN ANSWER BELOW

#define VALUE(_INDEX_) [NSValue valueWithCGPoint:points[_INDEX_]]

#define POINT(_INDEX_) [(NSValue *)[points objectAtIndex:_INDEX_] CGPointValue]

- (UIBezierPath*)smoothedPathWithGranularity:(NSInteger)granularity

{

Â Â Â Â NSMutableArray *points = [(NSMutableArray*)[self pointsOrdered] mutableCopy];

Â Â Â Â if (points.count < 4) return [self bezierPath];

Â Â Â Â // Add control points to make the math make sense

Â Â Â Â [points insertObject:[points objectAtIndex:0] atIndex:0];

Â Â Â Â [points addObject:[points lastObject]];

Â Â Â Â UIBezierPath *smoothedPath = [self bezierPath];

Â Â Â Â [smoothedPath removeAllPoints];

Â Â Â Â [smoothedPath moveToPoint:POINT(0)];

Â Â Â Â for (NSUInteger index = 1; index < points.count - 2; index++)

Â Â Â Â {

Â Â Â Â Â Â Â Â CGPoint p0 = POINT(index - 1);

Â Â Â Â Â Â Â Â CGPoint p1 = POINT(index);

Â Â Â Â Â Â Â Â CGPoint p2 = POINT(index + 1);

Â Â Â Â Â Â Â Â CGPoint p3 = POINT(index + 2);

Â Â Â Â Â Â Â Â // now add n points starting at p1 + dx/dy up until p2 using Catmull-Rom splines

Â Â Â Â Â Â Â Â for (int i = 1; i < granularity; i++)

Â Â Â Â Â Â Â Â {

Â Â Â Â Â Â Â Â Â Â Â Â float t = (float) i * (1.0f / (float) granularity);

Â Â Â Â Â Â Â Â Â Â Â Â float tt = t * t;

Â Â Â Â Â Â Â Â Â Â Â Â float ttt = tt * t;

Â Â Â Â Â Â Â Â Â Â Â Â CGPoint pi; // intermediate point

Â Â Â Â Â Â Â Â Â Â Â Â pi.x = 0.5 * (2*p1.x+(p2.x-p0.x)*t + (2*p0.x-5*p1.x+4*p2.x-p3.x)*tt + (3*p1.x-p0.x-3*p2.x+p3.x)*ttt);

Â Â Â Â Â Â Â Â Â Â Â Â pi.y = 0.5 * (2*p1.y+(p2.y-p0.y)*t + (2*p0.y-5*p1.y+4*p2.y-p3.y)*tt + (3*p1.y-p0.y-3*p2.y+p3.y)*ttt);

Â Â Â Â Â Â Â Â Â Â Â Â [smoothedPath addLineToPoint:pi];

Â Â Â Â Â Â Â Â }

Â Â Â Â Â Â Â Â // Now add p2

Â Â Â Â Â Â Â Â [smoothedPath addLineToPoint:p2];

Â Â Â Â }

Â Â Â Â // finish by adding the last point

Â Â Â Â [smoothedPath addLineToPoint:POINT(points.count - 1)];

Â Â Â Â return smoothedPath;

}

- (PVPoint *)pointAppendingCGPoint:(CGPoint)CGPoint

{

Â Â Â Â PVPoint *newPoint = [[PVPoint alloc] initInsertingIntoManagedObjectContext:[self managedObjectContext]];

Â Â Â Â [newPoint setCGPoint:CGPoint];

Â Â Â Â [newPoint setOrder:[NSNumber numberWithUnsignedInteger:[[self points] count]]];

Â Â Â Â [[self mutableSetValueForKey:@"points"] addObject:newPoint];

Â Â Â Â [(NSMutableArray *)[self pointsOrdered] addObject:newPoint];

Â Â Â Â [[self bezierPath] addLineToPoint:CGPoint];

Â Â Â Â return [newPoint autorelease];

Â Â Â Â if ([self bezierPath] && [pointsOrdered count] > 3)

Â Â Â Â {

Â Â Â Â Â Â Â Â PVPoint *control1 = [pointsOrdered objectAtIndex:[pointsOrdered count] - 2];

Â Â Â Â Â Â Â Â PVPoint *control2 = [pointsOrdered objectAtIndex:[pointsOrdered count] - 1];

Â Â Â Â Â Â Â Â [bezierPath moveToPoint:[[pointsOrdered objectAtIndex:[pointsOrdered count] - 3] CGPoint]];

Â Â Â Â Â Â Â Â [[self bezierPath] addCurveToPoint:CGPoint controlPoint1:[control1 CGPoint] controlPoint2:[control2 CGPoint]];

Â Â Â Â }

}

- (BOOL)isComplete { return [[self points] count] > 1; }

- (UIBezierPath *)bezierPath

{

Â Â Â Â if (!bezierPath)

Â Â Â Â {

Â Â Â Â Â Â Â Â bezierPath = [UIBezierPath bezierPath];

Â Â Â Â Â Â Â Â for (NSUInteger p = 0; p < [[self points] count]; p++)

Â Â Â Â Â Â Â Â {

Â Â Â Â Â Â Â Â Â Â Â Â if (!p) [bezierPath moveToPoint:[(PVPoint *)[[self pointsOrdered] objectAtIndex:p] CGPoint]];

Â Â Â Â Â Â Â Â Â Â Â Â else [bezierPath addLineToPoint:[(PVPoint *)[[self pointsOrdered] objectAtIndex:p] CGPoint]];

Â Â Â Â Â Â Â Â }

Â Â Â Â Â Â Â Â [bezierPath retain];

Â Â Â Â }

Â Â Â Â return bezierPath;

}

- (CGPathRef)CGPath

{

Â Â Â Â return [[self bezierPath] CGPath];

}

Â Â Â Â

Like everyone before has asked, how do you smooth a set of points in an iOS drawing app WHILE MOVING? I have tried UIBezierpaths but all I get are jagged ends where they intersect, when I just shift the points 1,2,3,4 - 2,3,4,5. I have heard of spline curves and all the other types. I am quite new to iPhone programming and do not understand how to program it in my quartz drawing app. A solid example would be greatly appreciated, I have spent weeks running in circles and I can never seem to find any iOS code for this task. Most of the posts just link to a java simulation or pages on wikipedia about curve fitting which does nothing for me. Also I do not want to switch to openGL ES. I hope someone can finally provide code to answer this circulating question.

Thank You, Happy New Year!!!

.....................................................................................................................................................................

This was my code for the UIBezierPath which left edges at intersection///

UPDATED TO AN ANSWER BELOW

#define VALUE(_INDEX_) [NSValue valueWithCGPoint:points[_INDEX_]]

#define POINT(_INDEX_) [(NSValue *)[points objectAtIndex:_INDEX_] CGPointValue]

- (UIBezierPath*)smoothedPathWithGranularity:(NSInteger)granularity

{

Â Â Â Â NSMutableArray *points = [(NSMutableArray*)[self pointsOrdered] mutableCopy];

Â Â Â Â if (points.count < 4) return [self bezierPath];

Â Â Â Â // Add control points to make the math make sense

Â Â Â Â [points insertObject:[points objectAtIndex:0] atIndex:0];

Â Â Â Â [points addObject:[points lastObject]];

Â Â Â Â UIBezierPath *smoothedPath = [self bezierPath];

Â Â Â Â [smoothedPath removeAllPoints];

Â Â Â Â [smoothedPath moveToPoint:POINT(0)];

Â Â Â Â for (NSUInteger index = 1; index < points.count - 2; index++)

Â Â Â Â {

Â Â Â Â Â Â Â Â CGPoint p0 = POINT(index - 1);

Â Â Â Â Â Â Â Â CGPoint p1 = POINT(index);

Â Â Â Â Â Â Â Â CGPoint p2 = POINT(index + 1);

Â Â Â Â Â Â Â Â CGPoint p3 = POINT(index + 2);

Â Â Â Â Â Â Â Â // now add n points starting at p1 + dx/dy up until p2 using Catmull-Rom splines

Â Â Â Â Â Â Â Â for (int i = 1; i < granularity; i++)

Â Â Â Â Â Â Â Â {

Â Â Â Â Â Â Â Â Â Â Â Â float t = (float) i * (1.0f / (float) granularity);

Â Â Â Â Â Â Â Â Â Â Â Â float tt = t * t;

Â Â Â Â Â Â Â Â Â Â Â Â float ttt = tt * t;

Â Â Â Â Â Â Â Â Â Â Â Â CGPoint pi; // intermediate point

Â Â Â Â Â Â Â Â Â Â Â Â pi.x = 0.5 * (2*p1.x+(p2.x-p0.x)*t + (2*p0.x-5*p1.x+4*p2.x-p3.x)*tt + (3*p1.x-p0.x-3*p2.x+p3.x)*ttt);

Â Â Â Â Â Â Â Â Â Â Â Â pi.y = 0.5 * (2*p1.y+(p2.y-p0.y)*t + (2*p0.y-5*p1.y+4*p2.y-p3.y)*tt + (3*p1.y-p0.y-3*p2.y+p3.y)*ttt);

Â Â Â Â Â Â Â Â Â Â Â Â [smoothedPath addLineToPoint:pi];

Â Â Â Â Â Â Â Â }

Â Â Â Â Â Â Â Â // Now add p2

Â Â Â Â Â Â Â Â [smoothedPath addLineToPoint:p2];

Â Â Â Â }

Â Â Â Â // finish by adding the last point

Â Â Â Â [smoothedPath addLineToPoint:POINT(points.count - 1)];

Â Â Â Â return smoothedPath;

}

- (PVPoint *)pointAppendingCGPoint:(CGPoint)CGPoint

{

Â Â Â Â PVPoint *newPoint = [[PVPoint alloc] initInsertingIntoManagedObjectContext:[self managedObjectContext]];

Â Â Â Â [newPoint setCGPoint:CGPoint];

Â Â Â Â [newPoint setOrder:[NSNumber numberWithUnsignedInteger:[[self points] count]]];

Â Â Â Â [[self mutableSetValueForKey:@"points"] addObject:newPoint];

Â Â Â Â [(NSMutableArray *)[self pointsOrdered] addObject:newPoint];

Â Â Â Â [[self bezierPath] addLineToPoint:CGPoint];

Â Â Â Â return [newPoint autorelease];

Â Â Â Â if ([self bezierPath] && [pointsOrdered count] > 3)

Â Â Â Â {

Â Â Â Â Â Â Â Â PVPoint *control1 = [pointsOrdered objectAtIndex:[pointsOrdered count] - 2];

Â Â Â Â Â Â Â Â PVPoint *control2 = [pointsOrdered objectAtIndex:[pointsOrdered count] - 1];

Â Â Â Â Â Â Â Â [bezierPath moveToPoint:[[pointsOrdered objectAtIndex:[pointsOrdered count] - 3] CGPoint]];

Â Â Â Â Â Â Â Â [[self bezierPath] addCurveToPoint:CGPoint controlPoint1:[control1 CGPoint] controlPoint2:[control2 CGPoint]];

Â Â Â Â }

}

- (BOOL)isComplete { return [[self points] count] > 1; }

- (UIBezierPath *)bezierPath

{

Â Â Â Â if (!bezierPath)

Â Â Â Â {

Â Â Â Â Â Â Â Â bezierPath = [UIBezierPath bezierPath];

Â Â Â Â Â Â Â Â for (NSUInteger p = 0; p < [[self points] count]; p++)

Â Â Â Â Â Â Â Â {

Â Â Â Â Â Â Â Â Â Â Â Â if (!p) [bezierPath moveToPoint:[(PVPoint *)[[self pointsOrdered] objectAtIndex:p] CGPoint]];

Â Â Â Â Â Â Â Â Â Â Â Â else [bezierPath addLineToPoint:[(PVPoint *)[[self pointsOrdered] objectAtIndex:p] CGPoint]];

Â Â Â Â Â Â Â Â }

Â Â Â Â Â Â Â Â [bezierPath retain];

Â Â Â Â }

Â Â Â Â return bezierPath;

}

- (CGPathRef)CGPath

{

Â Â Â Â return [[self bezierPath] CGPath];

}

Â Â Â Â

0 votes

0 votes

I just implemented something similar in a project I am working on. My solution was to use a Catmull-Rom spline instead of using Bezier splines. These provide a very smooth curve THROUGH a set a points rather then a bezier spline 'around' points.

```
// Based on code from Erica Sadun
#import "UIBezierPath+Smoothing.h"
void getPointsFromBezier(void *info, const CGPathElement *element);
NSArray *pointsFromBezierPath(UIBezierPath *bpath);
#define VALUE(_INDEX_) [NSValue valueWithCGPoint:points[_INDEX_]]
#define POINT(_INDEX_) [(NSValue *)[points objectAtIndex:_INDEX_] CGPointValue]
@implementation UIBezierPath (Smoothing)
// Get points from Bezier Curve
void getPointsFromBezier(void *info, const CGPathElement *element)
{
NSMutableArray *bezierPoints = (__bridge NSMutableArray *)info;
// Retrieve the path element type and its points
CGPathElementType type = element->type;
CGPoint *points = element->points;
// Add the points if they're available (per type)
if (type != kCGPathElementCloseSubpath)
{
[bezierPoints addObject:VALUE(0)];
if ((type != kCGPathElementAddLineToPoint) &&
(type != kCGPathElementMoveToPoint))
[bezierPoints addObject:VALUE(1)];
}
if (type == kCGPathElementAddCurveToPoint)
[bezierPoints addObject:VALUE(2)];
}
NSArray *pointsFromBezierPath(UIBezierPath *bpath)
{
NSMutableArray *points = [NSMutableArray array];
CGPathApply(bpath.CGPath, (__bridge void *)points, getPointsFromBezier);
return points;
}
- (UIBezierPath*)smoothedPathWithGranularity:(NSInteger)granularity;
{
NSMutableArray *points = [pointsFromBezierPath(self) mutableCopy];
if (points.count < 4) return [self copy];
// Add control points to make the math make sense
[points insertObject:[points objectAtIndex:0] atIndex:0];
[points addObject:[points lastObject]];
UIBezierPath *smoothedPath = [self copy];
[smoothedPath removeAllPoints];
[smoothedPath moveToPoint:POINT(0)];
for (NSUInteger index = 1; index < points.count - 2; index++)
{
CGPoint p0 = POINT(index - 1);
CGPoint p1 = POINT(index);
CGPoint p2 = POINT(index + 1);
CGPoint p3 = POINT(index + 2);
// now add n points starting at p1 + dx/dy up until p2 using Catmull-Rom splines
for (int i = 1; i < granularity; i++)
{
float t = (float) i * (1.0f / (float) granularity);
float tt = t * t;
float ttt = tt * t;
CGPoint pi; // intermediate point
pi.x = 0.5 * (2*p1.x+(p2.x-p0.x)*t + (2*p0.x-5*p1.x+4*p2.x-p3.x)*tt + (3*p1.x-p0.x-3*p2.x+p3.x)*ttt);
pi.y = 0.5 * (2*p1.y+(p2.y-p0.y)*t + (2*p0.y-5*p1.y+4*p2.y-p3.y)*tt + (3*p1.y-p0.y-3*p2.y+p3.y)*ttt);
[smoothedPath addLineToPoint:pi];
}
// Now add p2
[smoothedPath addLineToPoint:p2];
}
// finish by adding the last point
[smoothedPath addLineToPoint:POINT(points.count - 1)];
return smoothedPath;
}
@end
```

The original Catmull-Rom implementation is based on some code from Erica Sadun in one of her books, I modified it slightly to allow for a full smoothed curve. This is implemented as a category on UIBezierPath and worked out very well for me.

0 votes

The key to getting two bezier curves to join smoothly is that the relevant control points and the start/end points on the curves must be collinear. Think of the control point and the endpoint as forming a line that's tangent to the curve at the endpoint. If one curve starts at the same point where another ends, and if they both have the same tangent line at that point, the curve will be smooth. Here's a bit of code to illustrate:

```
- (void)drawRect:(CGRect)rect
{
#define commonY 117
CGPoint point1 = CGPointMake(20, 20);
CGPoint point2 = CGPointMake(100, commonY);
CGPoint point3 = CGPointMake(200, 50);
CGPoint controlPoint1 = CGPointMake(50, 60);
CGPoint controlPoint2 = CGPointMake(20, commonY);
CGPoint controlPoint3 = CGPointMake(200, commonY);
CGPoint controlPoint4 = CGPointMake(250, 75);
UIBezierPath *path1 = [UIBezierPath bezierPath];
UIBezierPath *path2 = [UIBezierPath bezierPath];
[path1 setLineWidth:3.0];
[path1 moveToPoint:point1];
[path1 addCurveToPoint:point2 controlPoint1:controlPoint1 controlPoint2:controlPoint2];
[[UIColor blueColor] set];
[path1 stroke];
[path2 setLineWidth:3.0];
[path2 moveToPoint:point2];
[path2 addCurveToPoint:point3 controlPoint1:controlPoint3 controlPoint2:controlPoint4];
[[UIColor orangeColor] set];
[path2 stroke];
}
```

Notice that `path1`

ends at `point2`

, `path2`

starts at `point2`

, and control points 2 and 3 share the same Y-value, `commonY`

, with `point2`

. You can change any of the values in the code as you like; as long as those three points all fall on the same line, the two paths will join smoothly. (In the code above, the line is `y = commonY`

. The line doesn't have to be parallel to the X axis; it's just easier to see that the points are collinear that way.)

Here's the image that the code above draws:

After looking at your code, the reason that your curve is jagged is that you're thinking of control points as points on the curve. In a bezier curve, the control points are usually not on the curve. Since you're taking the control points from the curve, the control points and the point of intersection are *not* collinear, and the paths therefore don't join smoothly.

0 votes

@Rakesh is absolutely right - you dont need to use Catmull-Rom algorithm if you just want a curved line. And the link he suggested does exacly that. So here's addition to his answer.

The code bellow DOES NOT use Catmull-Rom algorithm & granularity, but draws a quad-curved line (control points are calculated for you). This is essentially what's done in the ios freehand drawing tutorial suggested by Rakesh, but in a standalone method that you can drop anywhere (or in a UIBezierPath category) and get a quad-curved spline out of the box.

You do need to have an array of `CGPoint`

's wrapped in `NSValue`

's

```
+ (UIBezierPath *)quadCurvedPathWithPoints:(NSArray *)points
{
UIBezierPath *path = [UIBezierPath bezierPath];
NSValue *value = points[0];
CGPoint p1 = [value CGPointValue];
[path moveToPoint:p1];
if (points.count == 2) {
value = points[1];
CGPoint p2 = [value CGPointValue];
[path addLineToPoint:p2];
return path;
}
for (NSUInteger i = 1; i < points.count; i++) {
value = points[i];
CGPoint p2 = [value CGPointValue];
CGPoint midPoint = midPointForPoints(p1, p2);
[path addQuadCurveToPoint:midPoint controlPoint:controlPointForPoints(midPoint, p1)];
[path addQuadCurveToPoint:p2 controlPoint:controlPointForPoints(midPoint, p2)];
p1 = p2;
}
return path;
}
static CGPoint midPointForPoints(CGPoint p1, CGPoint p2) {
return CGPointMake((p1.x + p2.x) / 2, (p1.y + p2.y) / 2);
}
static CGPoint controlPointForPoints(CGPoint p1, CGPoint p2) {
CGPoint controlPoint = midPointForPoints(p1, p2);
CGFloat diffY = abs(p2.y - controlPoint.y);
if (p1.y < p2.y)
controlPoint.y += diffY;
else if (p1.y > p2.y)
controlPoint.y -= diffY;
return controlPoint;
}
```

Here's the result:

0 votes

For achieving this we need to use this method. BezierSpline the code is in C# to generate arrays of control points for a bezier spline. I converted this code to Objective C and it works brilliantly for me.

To convert the code from C# to Objective C. understand the C# code line by line, even if you dont know C#, u must be knowing C++/Java ?

While converting:

Replace Point struct used here with CGPoint.

Replace Point array with NSMutableArray and store NSvalues wrapping CGPoints in it.

Replace all double arrays with NSMutableArrays and store NSNumber wrapping double in it.

use objectAtIndex: method in case of subscript for accessing array elements.

use replaceObjectAtIndex:withObject: to store objects at specific index.

Remember that NSMutableArray is a linkedList and what C# uses are dynamic arrays so they already have existing indices. In your case, in a NSMutableArray if it is empty, you cant store objects at random indices as the C# code does. they at times in this C# code, populate index 1 before index 0 and they can do so as index 1 exists. in NSMutabelArrays here, index 1 should be there if u want to call replaceObject on it. so before storing anything make a method that will add n NSNull objects in the NSMutableArray.

ALSO :

well this logic has a static method that will accept an array of points and give you two arrays:-

array of first control points.

array of second control points.

These arrays will hold first and second control point for each curve between two points you pass in the first array.

In my case, I already had all the points and I could draw curve through them.

In you case while drawing, you will need to some how supply a set of points through which you want a smooth curve to pass.

and refresh by calling setNeedsDisplay and draw the spline which is nothing but UIBezierPath between two adjacent points in the first array. and taking control points from both the control point arrays index wise.

Problem in your case is that, its difficult to understand while moving what all critical points to take.

What you can do is: Simply while moving the finger keep drawing straight lines between previous and current point. Lines will be so small that it wont be visible to naked eye that they are small small straight lines unless you zoom in.

**UPDATE**

Anyone interested in an Objective C implementation of the link above can refer to

this GitHub repo.

I wrote it sometime back and it doesn't support ARC, but you can easily edit it and remove few release and autorelease calls and get it working with ARC.

This one just generates two arrays of control points for a set of points which one wants to join using bezier spline.

0 votes

We need to observe some thing before applying any algorithm on captured points.

- Generally UIKit does not give the points at equal distance.
- We need to calculate the intermediate points in between two CGPoints[ Which has captured with Touch moved method]

Now to get smooth line, there are so many ways.

Some times we can achieve the by applying second degree polynomial or third degree polynomial or catmullRomSpline algorithms

```
- (float)findDistance:(CGPoint)point lineA:(CGPoint)lineA lineB:(CGPoint)lineB
{
CGPoint v1 = CGPointMake(lineB.x - lineA.x, lineB.y - lineA.y);
CGPoint v2 = CGPointMake(point.x - lineA.x, point.y - lineA.y);
float lenV1 = sqrt(v1.x * v1.x + v1.y * v1.y);
float lenV2 = sqrt(v2.x * v2.x + v2.y * v2.y);
float angle = acos((v1.x * v2.x + v1.y * v2.y) / (lenV1 * lenV2));
return sin(angle) * lenV2;
}
- (NSArray *)douglasPeucker:(NSArray *)points epsilon:(float)epsilon
{
int count = [points count];
if(count < 3) {
return points;
}
//Find the point with the maximum distance
float dmax = 0;
int index = 0;
for(int i = 1; i < count - 1; i++) {
CGPoint point = [[points objectAtIndex:i] CGPointValue];
CGPoint lineA = [[points objectAtIndex:0] CGPointValue];
CGPoint lineB = [[points objectAtIndex:count - 1] CGPointValue];
float d = [self findDistance:point lineA:lineA lineB:lineB];
if(d > dmax) {
index = i;
dmax = d;
}
}
//If max distance is greater than epsilon, recursively simplify
NSArray *resultList;
if(dmax > epsilon) {
NSArray *recResults1 = [self douglasPeucker:[points subarrayWithRange:NSMakeRange(0, index + 1)] epsilon:epsilon];
NSArray *recResults2 = [self douglasPeucker:[points subarrayWithRange:NSMakeRange(index, count - index)] epsilon:epsilon];
NSMutableArray *tmpList = [NSMutableArray arrayWithArray:recResults1];
[tmpList removeLastObject];
[tmpList addObjectsFromArray:recResults2];
resultList = tmpList;
} else {
resultList = [NSArray arrayWithObjects:[points objectAtIndex:0], [points objectAtIndex:count - 1],nil];
}
return resultList;
}
- (NSArray *)catmullRomSplineAlgorithmOnPoints:(NSArray *)points segments:(int)segments
{
int count = [points count];
if(count < 4) {
return points;
}
float b[segments][4];
{
// precompute interpolation parameters
float t = 0.0f;
float dt = 1.0f/(float)segments;
for (int i = 0; i < segments; i++, t+=dt) {
float tt = t*t;
float ttt = tt * t;
b[i][0] = 0.5f * (-ttt + 2.0f*tt - t);
b[i][1] = 0.5f * (3.0f*ttt -5.0f*tt +2.0f);
b[i][2] = 0.5f * (-3.0f*ttt + 4.0f*tt + t);
b[i][3] = 0.5f * (ttt - tt);
}
}
NSMutableArray *resultArray = [NSMutableArray array];
{
int i = 0; // first control point
[resultArray addObject:[points objectAtIndex:0]];
for (int j = 1; j < segments; j++) {
CGPoint pointI = [[points objectAtIndex:i] CGPointValue];
CGPoint pointIp1 = [[points objectAtIndex:(i + 1)] CGPointValue];
CGPoint pointIp2 = [[points objectAtIndex:(i + 2)] CGPointValue];
float px = (b[j][0]+b[j][1])*pointI.x + b[j][2]*pointIp1.x + b[j][3]*pointIp2.x;
float py = (b[j][0]+b[j][1])*pointI.y + b[j][2]*pointIp1.y + b[j][3]*pointIp2.y;
[resultArray addObject:[NSValue valueWithCGPoint:CGPointMake(px, py)]];
}
}
for (int i = 1; i < count-2; i++) {
// the first interpolated point is always the original control point
[resultArray addObject:[points objectAtIndex:i]];
for (int j = 1; j < segments; j++) {
CGPoint pointIm1 = [[points objectAtIndex:(i - 1)] CGPointValue];
CGPoint pointI = [[points objectAtIndex:i] CGPointValue];
CGPoint pointIp1 = [[points objectAtIndex:(i + 1)] CGPointValue];
CGPoint pointIp2 = [[points objectAtIndex:(i + 2)] CGPointValue];
float px = b[j][0]*pointIm1.x + b[j][1]*pointI.x + b[j][2]*pointIp1.x + b[j][3]*pointIp2.x;
float py = b[j][0]*pointIm1.y + b[j][1]*pointI.y + b[j][2]*pointIp1.y + b[j][3]*pointIp2.y;
[resultArray addObject:[NSValue valueWithCGPoint:CGPointMake(px, py)]];
}
}
{
int i = count-2; // second to last control point
[resultArray addObject:[points objectAtIndex:i]];
for (int j = 1; j < segments; j++) {
CGPoint pointIm1 = [[points objectAtIndex:(i - 1)] CGPointValue];
CGPoint pointI = [[points objectAtIndex:i] CGPointValue];
CGPoint pointIp1 = [[points objectAtIndex:(i + 1)] CGPointValue];
float px = b[j][0]*pointIm1.x + b[j][1]*pointI.x + (b[j][2]+b[j][3])*pointIp1.x;
float py = b[j][0]*pointIm1.y + b[j][1]*pointI.y + (b[j][2]+b[j][3])*pointIp1.y;
[resultArray addObject:[NSValue valueWithCGPoint:CGPointMake(px, py)]];
}
}
// the very last interpolated point is the last control point
[resultArray addObject:[points objectAtIndex:(count - 1)]];
return resultArray;
}
```

0 votes

Dont need to write this much of code.

Just refer to the ios freehand drawing tutorial; it really smoothen the drawing, also cache mechanism is there so that performance does not go down even when you keep drawing continuously.

0 votes

...