5
// Created by DoG on 19.02.07.
6
// Copyright 2007 Doemoetoer Gulyas. All rights reserved.
9
#import "JigsawGenerator.h"
10
//#import "JigsawView.h"
11
#import "SimplexNoise.h"
12
#import "MersenneTwister.h"
15
#define SEG_LENGTH 10.0f
17
void FreeJigPieces(JigPieces pieces)
19
for (int i = 0; i < pieces.hcells; ++i)
20
for (int j = 0; j < pieces.vcells; ++j)
22
JigCell cell = pieces.cells[i][j];
23
CGPathRelease(cell.outline);
24
for (int k = 0; k < 4; ++k)
26
CGPathRelease(cell.segments[k].bpath);
27
free(cell.segments[k].points);
31
free(pieces.cells[0]);
35
static void ReverseOrderOfPoints(CGPoint* points, int count)
37
for (int i = 0; i < count/2; ++i)
39
CGPoint buf = points[i];
40
points[i] = points[count - 1 - i];
41
points[count - 1 - i] = buf;
45
static void FlipYOfPoints(CGPoint* points, unsigned count)
47
for (size_t i = 0; i < count; ++i)
49
points[i].y = -points[i].y;
53
static void FlipXOfSegment(JigSegment* seg)
55
for (size_t i = 0; i < seg->count; ++i)
57
seg->points[i].x = seg->xlen - seg->points[i].x;
63
void transformPointArray(CGAffineTransform transform, CGPoint* points, size_t count)
65
for (size_t i = 0; i < count; ++i)
66
points[i] = CGPointApplyAffineTransform(points[i], transform);
71
float diminishingWeight(float p, float size)
73
float w = 1.0f - fclampf(fabsf(p)/(0.5*size), 0.0f, 1.0f);
77
CGPoint weightedNoiseAtPoint(CGPoint p, SimplexNoise* noise, float distortion, float freq, CGSize size)
79
float nx = [noise noise3dWithX: p.x*freq Y: p.y*freq Z: 0.0f]*distortion;
80
float ny = [noise noise3dWithX: p.x*freq Y: p.y*freq Z: 1.0f]*distortion;
82
//NSLog(@"%.2f, %.2f", nx, ny);
84
float wx = diminishingWeight(p.x, size.width);
85
float wy = diminishingWeight(p.y, size.height);
89
return CGPointMake(p.x + nx*wx, p.y + ny*wy);
92
@implementation JigsawGenerator
94
- (JigPieces) generateJigsaw
96
// MersenneTwister* rgen = [[[MersenneTwister alloc] initWithSeed: seed] autorelease];
98
// determine enabled edges
99
int* enabledIndices = calloc([edgeFiles count], sizeof(int)); // freed
100
int enabledEdgeCount = 0;
101
for (size_t i = 0; i < [edgeFiles count]; ++i)
103
//id edge = [[[edgeFiles objectAtIndex: i] lastPathComponent] stringByDeletingPathExtension];
104
id edge = [edgeFiles objectAtIndex: i];
105
if ([[enabledEdges objectForKey: edge] intValue] != 1)
107
enabledIndices[enabledEdgeCount++] = i;
110
// make sure we got at least one edge
111
if (enabledEdgeCount == 0)
112
enabledIndices[enabledEdgeCount++] = 0;
117
SimplexNoise* noise = [[[SimplexNoise alloc] init] autorelease];
118
[noise setSeed: seed];
122
JigCell** cells = calloc(hcells, sizeof(JigCell*));
123
cells[0] = calloc(hcells*vcells, sizeof(JigCell));
124
for (int i = 1; i < hcells; ++i)
125
cells[i] = cells[i-1] + vcells;
127
// load template edge
128
// NSArray* edges = [NSBundle pathsForResourcesOfType: @"jigedge" inDirectory: [[NSBundle mainBundle] bundlePath]];
130
CGSize jigsawSize = CGSizeMake(width, height);
132
float cellWidth = width/hcells;
133
float cellHeight = height/vcells;
134
float cellAspect = cellWidth/cellHeight;
135
float xAdjust = MIN(1.0f, 1.0f/cellAspect);
136
float yAdjust = MIN(1.0f, cellAspect);
138
CGPoint segmentStarts[4] = {
139
{ 0.5*cellWidth, -0.5*cellHeight},
140
{ 0.5*cellWidth, 0.5*cellHeight},
141
{-0.5*cellWidth, 0.5*cellHeight},
142
{-0.5*cellWidth, -0.5*cellHeight},
146
for (int i = 0; i < hcells; ++i)
148
float cellx = -0.5*width + (0.5f+(float)i)*cellWidth;
149
for (int j = 0; j < vcells; ++j)
151
float celly = -0.5*height + (0.5f+(float)j)*cellHeight;
152
JigCell* cell = cells[i]+j;
154
cell->pos = CGPointMake(cellx,celly);
155
cell->attachmentPoints[0] = CGPointMake(cellx + 0.5*cellWidth, celly);
156
cell->attachmentPoints[1] = CGPointMake(cellx, celly + 0.5*cellHeight);
157
cell->attachmentPoints[2] = CGPointMake(cellx - 0.5*cellWidth, celly);
158
cell->attachmentPoints[3] = CGPointMake(cellx, celly - 0.5*cellHeight);
160
for (int k = 0; k < 4; ++k)
163
snoise = [noise noise3dWithX: 10*(i+(k==0?1:0)) Y: 10*(j+(k==1?1:0)) Z: 2.0f withOctaves: 1 ofType: 0];
165
cell->segments[k].count = 2;
166
cell->segments[k].xlen = SEG_LENGTH;
167
cell->segments[k].format = 0;
168
if ((j == 0) && (k == 3))
170
cell->segments[k].points = calloc(2, sizeof(CGPoint));
171
cell->segments[k].points[0] = (CGPointMake(0.0f, 0.0f));
172
cell->segments[k].points[1] = (CGPointMake(SEG_LENGTH, 0.0f));
174
else if ((j == vcells-1) && (k == 1))
176
cell->segments[k].points = calloc(2, sizeof(CGPoint));
177
cell->segments[k].points[0] = (CGPointMake(0.0f, 0.0f));
178
cell->segments[k].points[1] = (CGPointMake(SEG_LENGTH, 0.0f));
180
else if ((i == 0) && (k == 2))
182
cell->segments[k].points = calloc(2, sizeof(CGPoint));
183
cell->segments[k].points[0] = (CGPointMake(0.0f, 0.0f));
184
cell->segments[k].points[1] = (CGPointMake(SEG_LENGTH, 0.0f));
186
else if ((i == hcells-1) && (k == 0))
188
cell->segments[k].points = calloc(2, sizeof(CGPoint));
189
cell->segments[k].points[0] = (CGPointMake(0.0f, 0.0f));
190
cell->segments[k].points[1] = (CGPointMake(SEG_LENGTH, 0.0f));
194
// randomly select edge
195
JigSegment templateSegment;
199
//NSLog(@"selection noise %f %f %f", nval, 0.5f*(p.x+q.x), 0.5f*(p.y+q.y));
201
float nval = snoise + 1.0f;
202
nval *= 0.5f; // now in [0,1];
204
// multiply by large prime
207
nval = fmodf(nval,enabledEdgeCount);
209
//nval *= enabledEdgeCount*(1.0f - 2.0f*FLT_EPSILON);
210
assert((int)(nval) < enabledEdgeCount);
212
int edgeIndex = enabledIndices[(int)(nval)];
214
//id edgeName = [[[edgeFiles objectAtIndex: edgeIndex] lastPathComponent] stringByDeletingPathExtension];
215
id edgeName = [edgeFiles objectAtIndex: edgeIndex];
217
templateSegment = GetJigSegmentFromFile([edgeFiles objectAtIndex: edgeIndex]);
219
if (((templateSegment.format == 0) || (templateSegment.format == 2)) && ([[smoothedEdges objectForKey: edgeName] intValue] == 1))
221
templateSegment.format = 1;
227
cell->segments[k].count = templateSegment.count;
228
cell->segments[k].xlen = templateSegment.xlen;
229
cell->segments[k].format = templateSegment.format;
230
cell->segments[k].points = calloc(cell->segments[k].count, sizeof(CGPoint));
231
memcpy(cell->segments[k].points, templateSegment.points, templateSegment.count*sizeof(CGPoint));
233
// flip based on noise
236
for (size_t ii = 0; ii < cell->segments[k].count; ++ii)
237
cell->segments[k].points[ii].y = -cell->segments[k].points[ii].y;
240
free(templateSegment.points);
244
// rotate and scale segment to cell size
248
for (size_t ii = 0; ii < cell->segments[k].count; ++ii)
250
CGPoint p = cell->segments[k].points[ii];
251
p = CGPointMake(-p.y, p.x);
252
p.x *= cellWidth/SEG_LENGTH*xAdjust;
253
p.y *= cellHeight/SEG_LENGTH;
254
cell->segments[k].points[ii] = p;
258
for (size_t ii = 0; ii < cell->segments[k].count; ++ii)
260
CGPoint p = cell->segments[k].points[ii];
261
p = CGPointMake(-p.x, p.y);
262
p.x *= cellWidth/SEG_LENGTH;
263
p.y *= cellHeight/SEG_LENGTH*yAdjust;
264
cell->segments[k].points[ii] = p;
266
//ReverseOrderOfPoints(cell->segments[k].points, cell->segments[k].count);
269
for (size_t ii = 0; ii < cell->segments[k].count; ++ii)
271
CGPoint p = cell->segments[k].points[ii];
272
p = CGPointMake(-p.y, -p.x);
273
p.x *= cellWidth/SEG_LENGTH*xAdjust;
274
p.y *= cellHeight/SEG_LENGTH;
275
cell->segments[k].points[ii] = p;
277
//ReverseOrderOfPoints(cell->segments[k].points, cell->segments[k].count);
280
for (size_t ii = 0; ii < cell->segments[k].count; ++ii)
282
CGPoint p = cell->segments[k].points[ii];
283
p.x *= cellWidth/SEG_LENGTH;
284
p.y *= cellHeight/SEG_LENGTH*yAdjust;
285
cell->segments[k].points[ii] = p;
289
// transform local to global coords
290
for (size_t ii = 0; ii < cell->segments[k].count; ++ii)
292
CGPoint p = cell->segments[k].points[ii];
293
p = CGPointAdd(p, segmentStarts[k]);
294
p = CGPointAdd(p, CGPointMake(cellx, celly));
295
cell->segments[k].points[ii] = p;
299
// and now add some noise
301
cell->pos = weightedNoiseAtPoint(cell->pos, noise, distortion, frequency, jigsawSize);
302
for (size_t k = 0; k < 4; ++k)
304
cell->attachmentPoints[k] = weightedNoiseAtPoint(cell->attachmentPoints[k], noise, distortion, frequency, jigsawSize);
305
for (size_t ii = 0; ii < cell->segments[k].count; ++ii)
307
CGPoint p = cell->segments[k].points[ii];
308
p = weightedNoiseAtPoint(p, noise, distortion, frequency, jigsawSize);
309
cell->segments[k].points[ii] = p;
316
for (int i = 0; i < hcells; ++i)
318
for (int j = 0; j < vcells; ++j)
320
JigCell* cell = (cells[i]+j);
322
for (int k = 0; k < 4; ++k)
325
if (cell->segments[k].format == 1)
327
SplineSegmentToPiecewiseBezier( &(cell->segments[k]) );
330
// generate NSBeziers
332
CGMutablePathRef bpath = CGPathCreateMutable();
333
CGPathMoveToPoint(bpath, NULL, cell->segments[k].points[0].x, cell->segments[k].points[0].y);
335
switch(cell->segments[k].format)
339
for (size_t l = 1; l < cell->segments[k].count; ++l)
340
CGPathAddLineToPoint(bpath, NULL, cell->segments[k].points[l].x, cell->segments[k].points[l].y);
345
for (size_t l = 1; l < cell->segments[k].count; l+=3)
346
CGPathAddCurveToPoint(bpath, NULL, cell->segments[k].points[l].x, cell->segments[k].points[l].y, cell->segments[k].points[l+1].x, cell->segments[k].points[l+1].y, cell->segments[k].points[l+2].x, cell->segments[k].points[l+2].y);
350
NSLog(@"dammit, unkown point format: %d", cell->segments[k].format);
353
cell->segments[k].bpath = bpath;
357
// generate outline path
358
CGMutablePathRef bpath = CGPathCreateMutable();
359
for (int k = 0; k < 4; ++k)
362
CGPathMoveToPoint(bpath, NULL, cell->segments[k].points[0].x, cell->segments[k].points[0].y);
364
int pcount = cell->segments[k].count;
368
switch(cell->segments[k].format)
372
for (int l = 1; l < pcount; ++l)
373
CGPathAddLineToPoint(bpath, NULL, cell->segments[k].points[l].x, cell->segments[k].points[l].y);
378
for (int l = 1; l < pcount; l+=3)
379
CGPathAddCurveToPoint(bpath, NULL, cell->segments[k].points[l].x, cell->segments[k].points[l].y, cell->segments[k].points[l+1].x, cell->segments[k].points[l+1].y, cell->segments[k].points[l+2].x, cell->segments[k].points[l+2].y);
383
NSLog(@"dammit, unkown point format: %d", cell->segments[k].format);
387
CGPathCloseSubpath(bpath);
388
cell->outline = bpath;
394
free(enabledIndices);
399
pieces.hcells = hcells;
400
pieces.vcells = vcells;
401
pieces.cells = cells;
408
JigSegment GetJigSegmentFromFile(NSString* path)
410
FILE* file = fopen([path fileSystemRepresentation], "r");
411
float x = 0.0, y = 0.0;
415
CGPoint* buf = calloc(100, sizeof(CGPoint)); // retained
416
while(2 == fscanf(file, "%f %f", &x, &y))
420
fprintf(stderr, __FILE__ ", %d: Buffer size exceeded\n", __LINE__);
423
buf[i++] = CGPointMake(x,y);
428
if (1 == fscanf(file, "%c", &ch))
438
return (JigSegment){buf, i, x, format, NULL};
442
static CGPoint interpolate(CGPoint p, CGPoint q, float t)
444
return CGPointMake(p.x*(1.0f-t) + q.x*(t), p.y*(1.0f-t) + q.y*(t));
447
void SplineSegmentToPiecewiseBezier(JigSegment* seg)
449
int npieces = seg->count - 1;
450
int newpointcount = npieces*3 - 2;
451
CGPoint* newPoints = calloc(newpointcount, sizeof(CGPoint)); // retained
456
for (int i = 0; i < npieces; ++i)
458
CGPoint p = seg->points[i];
459
CGPoint q = seg->points[i+1];
463
newPoints[j++] = interpolate(p,q,0.5f);
464
//newPoints[j++] = q;
466
else if (i < npieces-1)
468
newPoints[j++] = interpolate(p,q,0.25f);
469
newPoints[j++] = interpolate(p,q,0.5f);
470
newPoints[j++] = interpolate(p,q,0.75f);
474
//newPoints[j++] = p;
475
newPoints[j++] = interpolate(p,q,0.5f);
482
seg->points = newPoints;
483
seg->count = newpointcount;
487
- (CGSize) puzzleSize
489
return CGSizeMake(width, height);
492
@synthesize width, height, frequency, distortion, hcells, vcells, seed, octaves, noiseType, roundEdgeCornerCoordsToInt, edgeFiles, enabledEdges, smoothedEdges;
added
removed
Jigs/source/JigsawGenerator.m
