Blame - tools/pathops_visualizer.htm - platform/external/skia

2014-06-17 05:15:38 -0700

[diff] [blame]

222

223

var decimal_places = 3; // make this 3 to show more precision

var tests = [];

var testLines = [];

var testTitles = [];

var testIndex = 0;

var ctx;

var xmin, xmax, focusXmin, focusXmax;

232

var ymin, ymax, focusYmin, focusYmax;

var scale;

var mouseX, mouseY;

var srcLeft, srcTop;

var screenWidth, screenHeight;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

237

var drawnPts, drawnLines, drawnQuads, drawnConics, drawnCubics;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

var curveT = 0;

var pt_labels = 2;

var collect_bounds = false;

242

var control_lines = 0;

243

var curve_t = false;

244

var debug_xy = 1;

245

var focus_enabled = false;

246

var focus_on_selection = false;

247

var step_limit = 0;

248

var draw_active = false;

249

var draw_add = false;

250

var draw_angle = 0;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

251

var draw_coincidence = false;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

252

var draw_deriviatives = 0;

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

253

var draw_direction = false;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

254

var draw_hints = false;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

255

var draw_id = false;

256

var draw_intersection = 0;

257

var draw_intersectT = false;

258

var draw_legend = true;

259

var draw_log = false;

260

var draw_mark = false;

261

var draw_midpoint = false;

262

var draw_op = 0;

263

var draw_sequence = false;

264

var draw_sort = 0;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

265

var draw_top = false;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

266

var draw_path = 3;

267

var draw_computed = 0;

268

var retina_scale = !!window.devicePixelRatio;

var activeCount = 0;

var addCount = 0;

var angleCount = 0;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

273

var coinCount = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

274

var opCount = 0;

275

var sectCount = 0;

276

var sortCount = 0;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

277

var topCount = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

var markCount = 0;

var activeMax = 0;

var addMax = 0;

var angleMax = 0;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

282

var coinMax = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

283

var sectMax = 0;

284

var sectMax2 = 0;

285

var sortMax = 0;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

286

var topMax = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

var markMax = 0;

var opMax = 0;

var stepMax = 0;

var lastIndex = 0;

var hasPath = false;

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

292

var hasAlignedPath = false;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

293

var hasComputedPath = false;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

294

var angleBetween = false;

295

var afterIndex = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

296

297

var firstActiveSpan = -1;

var logStart = -1;

var logRange = 0;

var SPAN_ID = 0;

var SPAN_X1 = SPAN_ID + 1;

303

var SPAN_Y1 = SPAN_X1 + 1;

304

var SPAN_X2 = SPAN_Y1 + 1;

305

var SPAN_Y2 = SPAN_X2 + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

306

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

307

var SPAN_L_TX = SPAN_Y2 + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

308

var SPAN_L_TY = SPAN_L_TX + 1;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

309

var SPAN_L_OTHER = SPAN_L_TY + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

310

var SPAN_L_OTHERT = SPAN_L_OTHER + 1;

311

var SPAN_L_OTHERI = SPAN_L_OTHERT + 1;

312

var SPAN_L_SUM = SPAN_L_OTHERI + 1;

313

var SPAN_L_VAL = SPAN_L_SUM + 1;

314

var SPAN_L_OPP = SPAN_L_VAL + 1;

315

316

var SPAN_X3 = SPAN_Y2 + 1;

317

var SPAN_Y3 = SPAN_X3 + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

318

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

319

var SPAN_Q_TX = SPAN_Y3 + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

320

var SPAN_Q_TY = SPAN_Q_TX + 1;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

321

var SPAN_Q_OTHER = SPAN_Q_TY + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

322

var SPAN_Q_OTHERT = SPAN_Q_OTHER + 1;

323

var SPAN_Q_OTHERI = SPAN_Q_OTHERT + 1;

324

var SPAN_Q_SUM = SPAN_Q_OTHERI + 1;

325

var SPAN_Q_VAL = SPAN_Q_SUM + 1;

326

var SPAN_Q_OPP = SPAN_Q_VAL + 1;

327

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

328

var SPAN_K_W = SPAN_Y3 + 1;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

329

var SPAN_K_TX = SPAN_K_W + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

330

var SPAN_K_TY = SPAN_K_TX + 1;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

331

var SPAN_K_OTHER = SPAN_K_TY + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

332

var SPAN_K_OTHERT = SPAN_K_OTHER + 1;

333

var SPAN_K_OTHERI = SPAN_K_OTHERT + 1;

334

var SPAN_K_SUM = SPAN_K_OTHERI + 1;

335

var SPAN_K_VAL = SPAN_K_SUM + 1;

336

var SPAN_K_OPP = SPAN_K_VAL + 1;

337

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

338

var SPAN_X4 = SPAN_Y3 + 1;

339

var SPAN_Y4 = SPAN_X4 + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

340

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

341

var SPAN_C_TX = SPAN_Y4 + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

342

var SPAN_C_TY = SPAN_C_TX + 1;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

343

var SPAN_C_OTHER = SPAN_C_TY + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

344

var SPAN_C_OTHERT = SPAN_C_OTHER + 1;

345

var SPAN_C_OTHERI = SPAN_C_OTHERT + 1;

346

var SPAN_C_SUM = SPAN_C_OTHERI + 1;

347

var SPAN_C_VAL = SPAN_C_SUM + 1;

348

var SPAN_C_OPP = SPAN_C_VAL + 1;

349

350

var ACTIVE_LINE_SPAN = 1;

351

var ACTIVE_QUAD_SPAN = ACTIVE_LINE_SPAN + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

352

var ACTIVE_CONIC_SPAN = ACTIVE_QUAD_SPAN + 1;

353

var ACTIVE_CUBIC_SPAN = ACTIVE_CONIC_SPAN + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

354

355

var ADD_MOVETO = ACTIVE_CUBIC_SPAN + 1;

356

var ADD_LINETO = ADD_MOVETO + 1;

357

var ADD_QUADTO = ADD_LINETO + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

358

var ADD_CONICTO = ADD_QUADTO + 1;

359

var ADD_CUBICTO = ADD_CONICTO + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

360

var ADD_CLOSE = ADD_CUBICTO + 1;

361

var ADD_FILL = ADD_CLOSE + 1;

362

363

var PATH_LINE = ADD_FILL + 1;

364

var PATH_QUAD = PATH_LINE + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

365

var PATH_CONIC = PATH_QUAD + 1;

366

var PATH_CUBIC = PATH_CONIC + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

367

368

var INTERSECT_LINE = PATH_CUBIC + 1;

369

var INTERSECT_LINE_2 = INTERSECT_LINE + 1;

370

var INTERSECT_LINE_NO = INTERSECT_LINE_2 + 1;

371

var INTERSECT_QUAD_LINE = INTERSECT_LINE_NO + 1;

372

var INTERSECT_QUAD_LINE_2 = INTERSECT_QUAD_LINE + 1;

373

var INTERSECT_QUAD_LINE_NO = INTERSECT_QUAD_LINE_2 + 1;

374

var INTERSECT_QUAD = INTERSECT_QUAD_LINE_NO + 1;

375

var INTERSECT_QUAD_2 = INTERSECT_QUAD + 1;

376

var INTERSECT_QUAD_NO = INTERSECT_QUAD_2 + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

377

var INTERSECT_CONIC_LINE = INTERSECT_QUAD_NO + 1;

378

var INTERSECT_CONIC_LINE_2 = INTERSECT_CONIC_LINE + 1;

379

var INTERSECT_CONIC_LINE_NO = INTERSECT_CONIC_LINE_2 + 1;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

380

var INTERSECT_CONIC_QUAD = INTERSECT_CONIC_LINE_NO + 1;

381

var INTERSECT_CONIC_QUAD_2 = INTERSECT_CONIC_QUAD + 1;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

382

var INTERSECT_CONIC_QUAD_3 = INTERSECT_CONIC_QUAD_2 + 1;

383

var INTERSECT_CONIC_QUAD_4 = INTERSECT_CONIC_QUAD_3 + 1;

384

var INTERSECT_CONIC_QUAD_NO = INTERSECT_CONIC_QUAD_4 + 1;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

385

var INTERSECT_CONIC = INTERSECT_CONIC_QUAD_NO + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

386

var INTERSECT_CONIC_2 = INTERSECT_CONIC + 1;

387

var INTERSECT_CONIC_NO = INTERSECT_CONIC_2 + 1;

388

var INTERSECT_SELF_CUBIC = INTERSECT_CONIC_NO + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

389

var INTERSECT_SELF_CUBIC_NO = INTERSECT_SELF_CUBIC + 1;

390

var INTERSECT_CUBIC_LINE = INTERSECT_SELF_CUBIC_NO + 1;

391

var INTERSECT_CUBIC_LINE_2 = INTERSECT_CUBIC_LINE + 1;

392

var INTERSECT_CUBIC_LINE_3 = INTERSECT_CUBIC_LINE_2 + 1;

393

var INTERSECT_CUBIC_LINE_NO = INTERSECT_CUBIC_LINE_3 + 1;

394

var INTERSECT_CUBIC_QUAD = INTERSECT_CUBIC_LINE_NO + 1;

395

var INTERSECT_CUBIC_QUAD_2 = INTERSECT_CUBIC_QUAD + 1;

396

var INTERSECT_CUBIC_QUAD_3 = INTERSECT_CUBIC_QUAD_2 + 1;

397

var INTERSECT_CUBIC_QUAD_4 = INTERSECT_CUBIC_QUAD_3 + 1;

398

var INTERSECT_CUBIC_QUAD_NO = INTERSECT_CUBIC_QUAD_4 + 1;

399

var INTERSECT_CUBIC = INTERSECT_CUBIC_QUAD_NO + 1;

400

var INTERSECT_CUBIC_2 = INTERSECT_CUBIC + 1;

401

var INTERSECT_CUBIC_3 = INTERSECT_CUBIC_2 + 1;

402

var INTERSECT_CUBIC_4 = INTERSECT_CUBIC_3 + 1;

403

// FIXME: add cubic 5- 9

404

var INTERSECT_CUBIC_NO = INTERSECT_CUBIC_4 + 1;

405

406

var SORT_UNARY = INTERSECT_CUBIC_NO + 1;

407

var SORT_BINARY = SORT_UNARY + 1;

408

409

var OP_DIFFERENCE = SORT_BINARY + 1;

410

var OP_INTERSECT = OP_DIFFERENCE + 1;

411

var OP_UNION = OP_INTERSECT + 1;

412

var OP_XOR = OP_UNION + 1;

413

414

var MARK_LINE = OP_XOR + 1;

415

var MARK_QUAD = MARK_LINE + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

416

var MARK_CONIC = MARK_QUAD + 1;

417

var MARK_CUBIC = MARK_CONIC + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

418

var MARK_DONE_LINE = MARK_CUBIC + 1;

419

var MARK_DONE_QUAD = MARK_DONE_LINE + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

420

var MARK_DONE_CONIC = MARK_DONE_QUAD + 1;

421

var MARK_DONE_CUBIC = MARK_DONE_CONIC + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

422

var MARK_UNSORTABLE_LINE = MARK_DONE_CUBIC + 1;

423

var MARK_UNSORTABLE_QUAD = MARK_UNSORTABLE_LINE + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

424

var MARK_UNSORTABLE_CONIC = MARK_UNSORTABLE_QUAD + 1;

425

var MARK_UNSORTABLE_CUBIC = MARK_UNSORTABLE_CONIC + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

426

var MARK_SIMPLE_LINE = MARK_UNSORTABLE_CUBIC + 1;

427

var MARK_SIMPLE_QUAD = MARK_SIMPLE_LINE + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

428

var MARK_SIMPLE_CONIC = MARK_SIMPLE_QUAD + 1;

429

var MARK_SIMPLE_CUBIC = MARK_SIMPLE_CONIC + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

430

var MARK_SIMPLE_DONE_LINE = MARK_SIMPLE_CUBIC + 1;

431

var MARK_SIMPLE_DONE_QUAD = MARK_SIMPLE_DONE_LINE + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

432

var MARK_SIMPLE_DONE_CONIC = MARK_SIMPLE_DONE_QUAD + 1;

433

var MARK_SIMPLE_DONE_CUBIC = MARK_SIMPLE_DONE_CONIC + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

434

var MARK_DONE_UNARY_LINE = MARK_SIMPLE_DONE_CUBIC + 1;

435

var MARK_DONE_UNARY_QUAD = MARK_DONE_UNARY_LINE + 1;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

436

var MARK_DONE_UNARY_CONIC = MARK_DONE_UNARY_QUAD + 1;

437

var MARK_DONE_UNARY_CUBIC = MARK_DONE_UNARY_CONIC + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

438

var MARK_ANGLE_LAST = MARK_DONE_UNARY_CUBIC + 1;

439

440

var COMPUTED_SET_1 = MARK_ANGLE_LAST + 1;

441

var COMPUTED_SET_2 = COMPUTED_SET_1 + 1;

442

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

443

var ANGLE_AFTER = COMPUTED_SET_2 + 1;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

444

var ANGLE_AFTERPART = ANGLE_AFTER + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

445

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

446

var ACTIVE_OP = ANGLE_AFTERPART + 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

447

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

448

var COIN_MAIN_SPAN = ACTIVE_OP + 1;

449

var COIN_OPP_SPAN = COIN_MAIN_SPAN + 1;

450

451

var FRAG_TYPE_LAST = COIN_OPP_SPAN;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

452

453

var REC_TYPE_UNKNOWN = -1;

454

var REC_TYPE_PATH = 0;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

455

var REC_TYPE_PATH2 = 1;

456

var REC_TYPE_SECT = 2;

457

var REC_TYPE_ACTIVE = 3;

458

var REC_TYPE_ADD = 4;

459

var REC_TYPE_SORT = 5;

460

var REC_TYPE_OP = 6;

461

var REC_TYPE_MARK = 7;

462

var REC_TYPE_COMPUTED = 8;

463

var REC_TYPE_COIN = 9;

464

var REC_TYPE_ANGLE = 10;

465

var REC_TYPE_ACTIVE_OP = 11;

466

var REC_TYPE_AFTERPART = 12;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

467

var REC_TYPE_TOP = 13;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

468

var REC_TYPE_COINCIDENCE = 14;

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

469

var REC_TYPE_ALIGNED = 15;

470

var REC_TYPE_LAST = REC_TYPE_ALIGNED;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

471

472

function strs_to_nums(strs) {

473

var result = [];

474

for (var idx = 1; idx < strs.length; ++idx) {

475

var str = strs[idx];

476

var num = parseFloat(str);

if (isNaN(num)) {

result.push(str);

} else {

result.push(num);

}

}

return result;

}

function filter_str_by(id, str, regex, array) {

487

if (regex.test(str)) {

488

var strs = regex.exec(str);

489

var result = strs_to_nums(strs);

array.push(id);

array.push(result);

return true;

}

return false;

}

function construct_regexp2(pattern) {

498

var escape = pattern.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');

499

escape = escape.replace(/UNSORTABLE/g, "\\*\\*\\* UNSORTABLE \\*\\*\\*");

500

escape = escape.replace(/CUBIC_VAL/g, "\$P_VAL P_VAL P_VAL P_VAL\$");

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

501

escape = escape.replace(/CONIC_VAL/g, "\$P_VAL P_VAL P_VAL W_VAL\$");

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

502

escape = escape.replace(/QUAD_VAL/g, "\$P_VAL P_VAL P_VAL\$");

503

escape = escape.replace(/LINE_VAL/g, "\$P_VAL P_VAL\$");

504

escape = escape.replace(/FILL_TYPE/g, "SkPath::k[a-zA-Z]+_FillType");

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

505

escape = escape.replace(/PTR_VAL/g, "0x[0-9A-F]+");

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

506

escape = escape.replace(/PT_VAL/g, "\$P_VAL\$");

507

escape = escape.replace(/P_VAL/g, "(-?\\d+\\.?\\d*(?:e-?\\d+)?)[Ff]?, ?(-?\\d+\\.?\\d*(?:e-?\\d+)?)[Ff]?");

508

escape = escape.replace(/T_VAL/g, "(-?\\d+\\.?\\d*(?:e-?\\d+)?)");

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

509

escape = escape.replace(/W_VAL/g, "(-?\\d+\\.?\\d*(?:e-?\\d+)?)[Ff]?");

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

510

escape = escape.replace(/PATH/g, "pathB?");

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

511

escape = escape.replace(/IDX/g, "(-?\\d+)");

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

512

escape = escape.replace(/NUM/g, "(-?\\d+)");

513

escape = escape.replace(/OPT/g, "(\\?|-?\\d+)");

514

return new RegExp(escape, 'i');

515

}

516

517

function construct_regexp2c(pattern) {

518

var escape = pattern.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');

519

escape = escape.replace(/UNSORTABLE/g, "\\*\\*\\* UNSORTABLE \\*\\*\\*");

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

520

escape = escape.replace(/CUBIC_VAL/g, "(?:\\$\\d = )?\\{\\{\\{P_VAL\\}, \\{P_VAL\\}, \\{P_VAL\\}, \\{P_VAL\\}\\}\\}");

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

521

escape = escape.replace(/CONIC_VAL/g, "(?:\\$\\d = )?\\{\\{\\{\\{P_VAL\\}, \\{P_VAL\\}, \\{P_VAL\\}\\}\\}, W_VAL\\}");

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

522

escape = escape.replace(/QUAD_VAL/g, "(?:\\$\\d = )?\\{\\{\\{P_VAL\\}, \\{P_VAL\\}, \\{P_VAL\\}\\}\\}");

523

escape = escape.replace(/LINE_VAL/g, "(?:\\$\\d = )?\\{\\{\\{P_VAL\\}, \\{P_VAL\\}\\}\\}");

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

524

escape = escape.replace(/FILL_TYPE/g, "SkPath::k[a-zA-Z]+_FillType");

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

525

escape = escape.replace(/PTR_VAL/g, "0x[0-9A-F]+");

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

526

escape = escape.replace(/PT_VAL/g, "\\{\\{P_VAL\\}\\}");

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

527

escape = escape.replace(/P_VAL/g, "(?:f?[xX] = )?(-?\\d+\\.?\\d*(?:e-?\\d+)?)[Ff]?, *(?: f?[yY] = )?(-?\\d+\\.?\\d*(?:e-?\\d+)?)[Ff]?");

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

528

escape = escape.replace(/T_VAL/g, "(-?\\d+\\.?\\d*(?:e-?\\d+)?)");

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

529

escape = escape.replace(/W_VAL/g, "(-?\\d+\\.?\\d*(?:e-?\\d+)?)[Ff]?");

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

530

escape = escape.replace(/OPER/g, "[a-z]+");

531

escape = escape.replace(/PATH/g, "pathB?");

532

escape = escape.replace(/T_F/g, "([TF])");

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

533

escape = escape.replace(/IDX/g, "(-?\\d+)");

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

534

escape = escape.replace(/NUM/g, "(-?\\d+)");

535

escape = escape.replace(/OPT/g, "(\\?|-?\\d+)");

536

return new RegExp(escape, 'i');

537

}

538

539

function match_regexp(str, lineNo, array, id, pattern) {

540

var regex = construct_regexp2(pattern);

541

if (filter_str_by(id, str, regex, array)) {

542

return true;

543

}

544

regex = construct_regexp2c(pattern);

545

return filter_str_by(id, str, regex, array);

546

}

547

548

function endsWith(str, suffix) {

549

return str.indexOf(suffix, str.length - suffix.length) !== -1;

550

}

551

552

function parse_all(test) {

553

var lines = test.match(/[^\r\n]+/g);

554

var records = []; // a rec can be the original paths, a set of intersections, a set of active spans, a sort, or a path add

555

var record = [];

556

var recType = REC_TYPE_UNKNOWN;

557

var lastLineNo;

558

var moveX, moveY;

559

for (var lineNo = 0; lineNo < lines.length; ++lineNo) {

560

var line = lines[lineNo];

561

if (line.length == 0) {

562

continue;

563

}

564

var opStart = "SkOpSegment::";

565

if (line.lastIndexOf(opStart, 0) === 0) {

566

line = line.substr(opStart.length);

567

}

568

var angleStart = "SkOpAngle::";

569

if (line.lastIndexOf(angleStart, 0) === 0) {

570

line = line.substr(angleStart.length);

571

}

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

572

var coinStart = "SkOpCoincidence::";

573

if (line.lastIndexOf(coinStart, 0) === 0) {

574

line = line.substr(coinStart.length);

575

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

576

var type = line.lastIndexOf("debugShowActiveSpans", 0) === 0 ? REC_TYPE_ACTIVE

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

577

: line.lastIndexOf("debugShowCoincidence", 0) === 0 ? REC_TYPE_COINCIDENCE

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

578

: line.lastIndexOf("((SkOpSegment*)", 0) === 0 ? REC_TYPE_PATH2

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

579

: line.lastIndexOf("debugShowTs", 0) === 0 ? REC_TYPE_COIN

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

580

: line.lastIndexOf("afterPart", 0) === 0 ? REC_TYPE_AFTERPART

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

581

: line.lastIndexOf("debugShow", 0) === 0 ? REC_TYPE_SECT

582

: line.lastIndexOf("activeOp", 0) === 0 ? REC_TYPE_ACTIVE_OP

583

: line.lastIndexOf("computed", 0) === 0 ? REC_TYPE_COMPUTED

584

: line.lastIndexOf("debugOne", 0) === 0 ? REC_TYPE_SORT

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

585

: line.lastIndexOf("aligned=", 0) === 0 ? REC_TYPE_ALIGNED

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

586

: line.lastIndexOf("dumpOne", 0) === 0 ? REC_TYPE_SORT

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

587

: line.lastIndexOf("findTop", 0) === 0 ? REC_TYPE_TOP

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

588

: line.lastIndexOf("pathB.", 0) === 0 ? REC_TYPE_ADD

589

: line.lastIndexOf("path.", 0) === 0 ? REC_TYPE_ADD

Cary Clark

59d5a0e

2017-01-23 14:38:52 +0000

[diff] [blame]

590

: line.lastIndexOf("after", 0) === 0 ? REC_TYPE_ANGLE

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

591

: line.lastIndexOf("mark", 0) === 0 ? REC_TYPE_MARK

592

: line.lastIndexOf(" {{", 0) === 0 ? REC_TYPE_COMPUTED

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

593

: line.lastIndexOf("seg=", 0) === 0 ? REC_TYPE_PATH

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

594

: line.lastIndexOf("op", 0) === 0 ? REC_TYPE_OP

595

: line.lastIndexOf("$", 0) === 0 ? REC_TYPE_PATH

596

: REC_TYPE_UNKNOWN;

597

if (recType != type || recType == REC_TYPE_ADD || recType == REC_TYPE_SECT

598

|| recType == REC_TYPE_ACTIVE_OP || recType == REC_TYPE_ANGLE) {

599

if (recType != REC_TYPE_UNKNOWN) {

600

records.push(recType);

601

records.push(lastLineNo);

602

records.push(record);

}

record = [];

recType = type;

lastLineNo = lineNo;

}

var found = false;

switch (recType) {

case REC_TYPE_ACTIVE:

611

found = match_regexp(line, lineNo, record, ACTIVE_LINE_SPAN, "debugShowActiveSpans" +

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

612

" id=IDX LINE_VAL t=T_VAL tEnd=T_VAL windSum=OPT windValue=IDX"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

613

) || match_regexp(line, lineNo, record, ACTIVE_QUAD_SPAN, "debugShowActiveSpans" +

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

614

" id=IDX QUAD_VAL t=T_VAL tEnd=T_VAL windSum=OPT windValue=IDX"

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

615

) || match_regexp(line, lineNo, record, ACTIVE_CONIC_SPAN, "debugShowActiveSpans" +

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

616

" id=IDX CONIC_VAL t=T_VAL tEnd=T_VAL windSum=OPT windValue=IDX"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

617

) || match_regexp(line, lineNo, record, ACTIVE_CUBIC_SPAN, "debugShowActiveSpans" +

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

618

" id=IDX CUBIC_VAL t=T_VAL tEnd=T_VAL windSum=OPT windValue=IDX"

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

619

) || match_regexp(line, lineNo, record, ACTIVE_LINE_SPAN, "debugShowActiveSpans" +

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

620

" id=IDX LINE_VAL t=T_VAL tEnd=T_VAL windSum=OPT oppSum=OPT windValue=IDX oppValue=NUM"

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

621

) || match_regexp(line, lineNo, record, ACTIVE_QUAD_SPAN, "debugShowActiveSpans" +

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

622

" id=IDX QUAD_VAL t=T_VAL tEnd=T_VAL windSum=OPT oppSum=OPT windValue=IDX oppValue=NUM"

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

623

) || match_regexp(line, lineNo, record, ACTIVE_CONIC_SPAN, "debugShowActiveSpans" +

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

624

" id=IDX CONIC_VAL t=T_VAL tEnd=T_VAL windSum=OPT oppSum=OPT windValue=IDX oppValue=NUM"

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

625

) || match_regexp(line, lineNo, record, ACTIVE_CUBIC_SPAN, "debugShowActiveSpans" +

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

626

" id=IDX CUBIC_VAL t=T_VAL tEnd=T_VAL windSum=OPT oppSum=OPT windValue=IDX oppValue=NUM"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

627

);

628

break;

629

case REC_TYPE_ACTIVE_OP:

630

found = match_regexp(line, lineNo, record, ACTIVE_OP, "activeOp" +

631

" id=IDX t=T_VAL tEnd=T_VAL op=OPER miFrom=NUM miTo=NUM suFrom=NUM suTo=NUM result=IDX"

);

break;

case REC_TYPE_ADD:

if (match_regexp(line, lineNo, record, ADD_MOVETO, "PATH.moveTo(P_VAL);")) {

636

moveX = record[1][0];

637

moveY = record[1][1];

638

found = true;

639

} else if (match_regexp(line, lineNo, record, ADD_LINETO, "PATH.lineTo(P_VAL);")) {

640

record[1].unshift(moveY);

641

record[1].unshift(moveX);

642

moveX = record[1][2];

643

moveY = record[1][3];

644

found = true;

645

} else if (match_regexp(line, lineNo, record, ADD_QUADTO, "PATH.quadTo(P_VAL, P_VAL);")) {

646

record[1].unshift(moveY);

647

record[1].unshift(moveX);

648

moveX = record[1][4];

649

moveY = record[1][5];

650

found = true;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

651

} else if (match_regexp(line, lineNo, record, ADD_CONICTO, "PATH.conicTo(P_VAL, P_VAL, T_VAL);")) {

652

record[1].unshift(moveY);

653

record[1].unshift(moveX);

654

moveX = record[1][4];

655

moveY = record[1][5];

656

found = true;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

657

} else if (match_regexp(line, lineNo, record, ADD_CUBICTO, "PATH.cubicTo(P_VAL, P_VAL, P_VAL);")) {

658

record[1].unshift(moveY);

659

record[1].unshift(moveX);

660

moveX = record[1][6];

661

moveY = record[1][7];

662

found = true;

663

} else if (match_regexp(line, lineNo, record, ADD_FILL, "PATH.setFillType(FILL_TYPE);")) {

664

found = true;

665

} else {

666

found = match_regexp(line, lineNo, record, ADD_CLOSE, "PATH.close();");

667

}

668

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

669

case REC_TYPE_AFTERPART:

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

670

found = match_regexp(line, lineNo, record, PATH_LINE, "afterPart LINE_VAL id=IDX")

671

|| match_regexp(line, lineNo, record, PATH_QUAD, "afterPart QUAD_VAL id=IDX")

672

|| match_regexp(line, lineNo, record, PATH_CONIC, "afterPart CONIC_VAL id=IDX")

673

|| match_regexp(line, lineNo, record, PATH_CUBIC, "afterPart CUBIC_VAL id=IDX")

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

674

break;

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

675

case REC_TYPE_ALIGNED:

676

found = match_regexp(line, lineNo, record, PATH_LINE, "aligned=IDX LINE_VAL"

677

) || match_regexp(line, lineNo, record, PATH_QUAD, "aligned=IDX QUAD_VAL"

678

) || match_regexp(line, lineNo, record, PATH_CONIC, "aligned=IDX CONIC_VAL"

679

) || match_regexp(line, lineNo, record, PATH_CUBIC, "aligned=IDX CUBIC_VAL"

680

);

681

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

682

case REC_TYPE_ANGLE:

Cary Clark

59d5a0e

2017-01-23 14:38:52 +0000

[diff] [blame]

683

found = match_regexp(line, lineNo, record, ANGLE_AFTER, "after " +

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

684

"[IDX/IDX] NUM/NUM tStart=T_VAL tEnd=T_VAL < [IDX/IDX] NUM/NUM tStart=T_VAL tEnd=T_VAL < [IDX/IDX] NUM/NUM tStart=T_VAL tEnd=T_VAL T_F IDX");

break;

case REC_TYPE_COIN:

found = true;

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

689

case REC_TYPE_COINCIDENCE:

690

found = match_regexp(line, lineNo, record, COIN_MAIN_SPAN, "debugShowCoincidence" +

691

" + id=IDX t=T_VAL tEnd=T_VAL"

692

) || match_regexp(line, lineNo, record, COIN_OPP_SPAN, "debugShowCoincidence" +

693

" - id=IDX t=T_VAL tEnd=T_VAL"

694

);

695

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

696

case REC_TYPE_COMPUTED:

697

found = line == "computed quadratics given"

698

|| match_regexp(line, lineNo, record, COMPUTED_SET_1, "computed quadratics set 1"

699

) || match_regexp(line, lineNo, record, COMPUTED_SET_2, "computed quadratics set 2"

700

) || match_regexp(line, lineNo, record, PATH_QUAD, " QUAD_VAL,"

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

701

) || match_regexp(line, lineNo, record, PATH_CONIC, " CONIC_VAL,"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

702

) || match_regexp(line, lineNo, record, PATH_CUBIC, " CUBIC_VAL,"

703

);

704

break;

705

case REC_TYPE_PATH:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

706

found = match_regexp(line, lineNo, record, PATH_LINE, "seg=IDX LINE_VAL"

707

) || match_regexp(line, lineNo, record, PATH_QUAD, "seg=IDX QUAD_VAL"

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

708

) || match_regexp(line, lineNo, record, PATH_CONIC, "seg=IDX CONIC_VAL"

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

709

) || match_regexp(line, lineNo, record, PATH_CUBIC, "seg=IDX CUBIC_VAL"

);

break;

case REC_TYPE_PATH2:

found = match_regexp(line, lineNo, record, PATH_LINE, "((SkOpSegment*) PTR_VAL) [IDX] {LINE_VAL}"

714

) || match_regexp(line, lineNo, record, PATH_QUAD, "((SkOpSegment*) PTR_VAL) [IDX] {QUAD_VAL}"

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

715

) || match_regexp(line, lineNo, record, PATH_CONIC, "((SkOpSegment*) PTR_VAL) [IDX] {CONIC_VAL}"

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

716

) || match_regexp(line, lineNo, record, PATH_CUBIC, "((SkOpSegment*) PTR_VAL) [IDX] {CUBIC_VAL}"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

);

break;

case REC_TYPE_SECT:

found = match_regexp(line, lineNo, record, INTERSECT_LINE, "debugShowLineIntersection" +

721

" wtTs[0]=T_VAL LINE_VAL PT_VAL wnTs[0]=T_VAL LINE_VAL"

722

) || match_regexp(line, lineNo, record, INTERSECT_LINE_2, "debugShowLineIntersection" +

723

" wtTs[0]=T_VAL LINE_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wnTs[0]=T_VAL LINE_VAL wnTs[1]=T_VAL"

724

) || match_regexp(line, lineNo, record, INTERSECT_LINE_NO, "debugShowLineIntersection" +

725

" no intersect LINE_VAL LINE_VAL"

726

) || match_regexp(line, lineNo, record, INTERSECT_QUAD_LINE, "debugShowQuadLineIntersection" +

727

" wtTs[0]=T_VAL QUAD_VAL PT_VAL wnTs[0]=T_VAL LINE_VAL"

728

) || match_regexp(line, lineNo, record, INTERSECT_QUAD_LINE_2, "debugShowQuadLineIntersection" +

729

" wtTs[0]=T_VAL QUAD_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wnTs[0]=T_VAL LINE_VAL wnTs[1]=T_VAL"

730

) || match_regexp(line, lineNo, record, INTERSECT_QUAD_LINE_NO, "debugShowQuadLineIntersection" +

731

" no intersect QUAD_VAL LINE_VAL"

732

) || match_regexp(line, lineNo, record, INTERSECT_QUAD, "debugShowQuadIntersection" +

733

" wtTs[0]=T_VAL QUAD_VAL PT_VAL wnTs[0]=T_VAL QUAD_VAL"

734

) || match_regexp(line, lineNo, record, INTERSECT_QUAD_2, "debugShowQuadIntersection" +

735

" wtTs[0]=T_VAL QUAD_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wnTs[0]=T_VAL QUAD_VAL wnTs[1]=T_VAL"

736

) || match_regexp(line, lineNo, record, INTERSECT_QUAD_NO, "debugShowQuadIntersection" +

737

" no intersect QUAD_VAL QUAD_VAL"

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

738

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

739

) || match_regexp(line, lineNo, record, INTERSECT_CONIC_LINE, "debugShowConicLineIntersection" +

740

" wtTs[0]=T_VAL CONIC_VAL PT_VAL wnTs[0]=T_VAL LINE_VAL"

741

) || match_regexp(line, lineNo, record, INTERSECT_CONIC_LINE_2, "debugShowConicLineIntersection" +

742

" wtTs[0]=T_VAL CONIC_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wnTs[0]=T_VAL LINE_VAL wnTs[1]=T_VAL"

743

) || match_regexp(line, lineNo, record, INTERSECT_CONIC_LINE_NO, "debugShowConicLineIntersection" +

744

" no intersect CONIC_VAL LINE_VAL"

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

745

746

) || match_regexp(line, lineNo, record, INTERSECT_CONIC_QUAD, "debugShowConicQuadIntersection" +

747

" wtTs[0]=T_VAL CONIC_VAL PT_VAL wnTs[0]=T_VAL QUAD_VAL"

748

) || match_regexp(line, lineNo, record, INTERSECT_CONIC_QUAD_2, "debugShowConicQuadIntersection" +

749

" wtTs[0]=T_VAL CONIC_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wnTs[0]=T_VAL QUAD_VAL wnTs[1]=T_VAL"

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

750

) || match_regexp(line, lineNo, record, INTERSECT_CONIC_QUAD_3, "debugShowConicQuadIntersection" +

751

" wtTs[0]=T_VAL CONIC_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wtTs[2]=T_VAL PT_VAL wnTs[0]=T_VAL QUAD_VAL wnTs[1]=T_VAL wnTs[2]=T_VAL"

752

) || match_regexp(line, lineNo, record, INTERSECT_CONIC_QUAD_4, "debugShowConicQuadIntersection" +

753

" wtTs[0]=T_VAL CONIC_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wtTs[2]=T_VAL PT_VAL wtTs[3]=T_VAL PT_VAL wnTs[0]=T_VAL QUAD_VAL wnTs[1]=T_VAL wnTs[2]=T_VAL wnTs[3]=T_VAL"

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

754

) || match_regexp(line, lineNo, record, INTERSECT_CONIC_QUAD_NO, "debugShowConicQuadIntersection" +

755

" no intersect CONIC_VAL QUAD_VAL"

756

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

757

) || match_regexp(line, lineNo, record, INTERSECT_CONIC, "debugShowConicIntersection" +

758

" wtTs[0]=T_VAL CONIC_VAL PT_VAL wnTs[0]=T_VAL CONIC_VAL"

759

) || match_regexp(line, lineNo, record, INTERSECT_CONIC_2, "debugShowConicIntersection" +

760

" wtTs[0]=T_VAL CONIC_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wnTs[0]=T_VAL CONIC_VAL wnTs[1]=T_VAL"

761

) || match_regexp(line, lineNo, record, INTERSECT_CONIC_NO, "debugShowConicIntersection" +

762

" no intersect CONIC_VAL CONIC_VAL"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

763

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC_LINE, "debugShowCubicLineIntersection" +

764

" wtTs[0]=T_VAL CUBIC_VAL PT_VAL wnTs[0]=T_VAL LINE_VAL"

765

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC_LINE_2, "debugShowCubicLineIntersection" +

766

" wtTs[0]=T_VAL CUBIC_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wnTs[0]=T_VAL LINE_VAL wnTs[1]=T_VAL"

767

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC_LINE_3, "debugShowCubicLineIntersection" +

768

" wtTs[0]=T_VAL CUBIC_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wtTs[2]=T_VAL PT_VAL wnTs[0]=T_VAL LINE_VAL wnTs[1]=T_VAL wnTs[2]=T_VAL"

769

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC_LINE_NO, "debugShowCubicLineIntersection" +

770

" no intersect CUBIC_VAL LINE_VAL"

771

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC_QUAD, "debugShowCubicQuadIntersection" +

772

" wtTs[0]=T_VAL CUBIC_VAL PT_VAL wnTs[0]=T_VAL QUAD_VAL"

773

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC_QUAD_2, "debugShowCubicQuadIntersection" +

774

" wtTs[0]=T_VAL CUBIC_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wnTs[0]=T_VAL QUAD_VAL wnTs[1]=T_VAL"

775

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC_QUAD_3, "debugShowCubicQuadIntersection" +

776

" wtTs[0]=T_VAL CUBIC_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wtTs[2]=T_VAL PT_VAL wnTs[0]=T_VAL QUAD_VAL wnTs[1]=T_VAL wnTs[2]=T_VAL"

777

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC_QUAD_4, "debugShowCubicQuadIntersection" +

778

" wtTs[0]=T_VAL CUBIC_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wtTs[2]=T_VAL wtTs[3]=T_VAL PT_VAL wnTs[0]=T_VAL QUAD_VAL wnTs[1]=T_VAL wnTs[2]=T_VAL wnTs[3]=T_VAL"

779

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC_QUAD_NO, "debugShowCubicQuadIntersection" +

780

" no intersect CUBIC_VAL QUAD_VAL"

781

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC, "debugShowCubicIntersection" +

782

" wtTs[0]=T_VAL CUBIC_VAL PT_VAL wnTs[0]=T_VAL CUBIC_VAL"

783

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC_2, "debugShowCubicIntersection" +

784

" wtTs[0]=T_VAL CUBIC_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wnTs[0]=T_VAL CUBIC_VAL wnTs[1]=T_VAL"

785

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC_3, "debugShowCubicIntersection" +

786

" wtTs[0]=T_VAL CUBIC_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wtTs[2]=T_VAL PT_VAL wnTs[0]=T_VAL CUBIC_VAL wnTs[1]=T_VAL wnTs[2]=T_VAL"

787

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC_4, "debugShowCubicIntersection" +

788

" wtTs[0]=T_VAL CUBIC_VAL PT_VAL wtTs[1]=T_VAL PT_VAL wtTs[2]=T_VAL PT_VAL wtTs[3]=T_VAL PT_VAL wnTs[0]=T_VAL CUBIC_VAL wnTs[1]=T_VAL wnTs[2]=T_VAL wnTs[3]=T_VAL"

789

) || match_regexp(line, lineNo, record, INTERSECT_CUBIC_NO, "debugShowCubicIntersection" +

790

" no intersect CUBIC_VAL CUBIC_VAL"

791

) || match_regexp(line, lineNo, record, INTERSECT_SELF_CUBIC, "debugShowCubicIntersection" +

792

" wtTs[0]=T_VAL CUBIC_VAL PT_VAL wtTs[1]=T_VAL"

793

) || match_regexp(line, lineNo, record, INTERSECT_SELF_CUBIC_NO, "debugShowCubicIntersection" +

794

" no self intersect CUBIC_VAL"

);

break;

case REC_TYPE_SORT:

var hasDone = / done/.test(line);

799

var hasUnorderable = / unorderable/.test(line);

800

var hasSmall = / small/.test(line);

801

var hasTiny = / tiny/.test(line);

802

var hasOperand = / operand/.test(line);

803

var hasStop = / stop/.test(line);

804

line.replace(/[ a-z]+$/, "");

805

found = match_regexp(line, lineNo, record, SORT_UNARY, "debugOne" +

806

" [IDX/IDX] next=IDX/IDX sect=IDX/IDX s=T_VAL [IDX] e=T_VAL [IDX] sgn=NUM windVal=IDX windSum=OPT"

807

) || match_regexp(line, lineNo, record, SORT_BINARY, "debugOne" +

808

" [IDX/IDX] next=IDX/IDX sect=IDX/IDX s=T_VAL [IDX] e=T_VAL [IDX] sgn=NUM windVal=IDX windSum=OPT oppVal=IDX oppSum=OPT"

809

) || match_regexp(line, lineNo, record, SORT_UNARY, "dumpOne" +

810

" [IDX/IDX] next=IDX/IDX sect=NUM/NUM s=T_VAL [IDX] e=T_VAL [IDX] sgn=NUM windVal=IDX windSum=OPT"

811

) || match_regexp(line, lineNo, record, SORT_BINARY, "dumpOne" +

812

" [IDX/IDX] next=IDX/IDX sect=NUM/NUM s=T_VAL [IDX] e=T_VAL [IDX] sgn=NUM windVal=IDX windSum=OPT oppVal=IDX oppSum=OPT"

813

);

814

if (found) {

815

record[1].push(hasDone);

816

record[1].push(hasUnorderable);

817

record[1].push(hasSmall);

818

record[1].push(hasTiny);

819

record[1].push(hasOperand);

820

record[1].push(hasStop);

821

}

822

break;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

823

case REC_TYPE_TOP:

824

found = match_regexp(line, lineNo, record, ACTIVE_OP, "findTop" +

825

" id=IDX s=T_VAL e=T_VAL cw=NUM swap=NUM inflections=NUM monotonic=NUM"

826

) || match_regexp(line, lineNo, record, ACTIVE_OP, "findTop" +

827

" id=IDX s=T_VAL e=T_VAL (-) cw=NUM swap=NUM inflections=NUM monotonic=NUM"

828

) || match_regexp(line, lineNo, record, ACTIVE_OP, "findTop" +

829

" id=IDX s=T_VAL e=T_VAL (+) cw=NUM swap=NUM inflections=NUM monotonic=NUM"

830

);

831

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

832

case REC_TYPE_MARK:

833

found = match_regexp(line, lineNo, record, MARK_LINE, "markWinding" +

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

834

" id=IDX LINE_VAL t=T_VAL [IDX] PT_VAL tEnd=T_VAL newWindSum=NUM newOppSum=OPT oppSum=OPT windSum=OPT windValue=IDX"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

835

) || match_regexp(line, lineNo, record, MARK_QUAD, "markWinding" +

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

836

" id=IDX QUAD_VAL t=T_VAL [IDX] PT_VAL tEnd=T_VAL newWindSum=NUM newOppSum=OPT oppSum=OPT windSum=OPT windValue=IDX"

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

837

) || match_regexp(line, lineNo, record, MARK_CONIC, "markWinding" +

838

" id=IDX CONIC_VAL t=T_VAL [IDX] PT_VAL tEnd=T_VAL newWindSum=NUM newOppSum=OPT oppSum=OPT windSum=OPT windValue=IDX"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

839

) || match_regexp(line, lineNo, record, MARK_CUBIC, "markWinding" +

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

840

" id=IDX CUBIC_VAL t=T_VAL [IDX] PT_VAL tEnd=T_VAL newWindSum=NUM newOppSum=OPT oppSum=OPT windSum=OPT windValue=IDX"

841

) || match_regexp(line, lineNo, record, MARK_DONE_LINE, "markDone" +

842

" id=IDX LINE_VAL t=T_VAL [IDX] PT_VAL tEnd=T_VAL newWindSum=OPT newOppSum=OPT oppSum=OPT windSum=OPT windValue=IDX oppValue=OPT"

843

) || match_regexp(line, lineNo, record, MARK_DONE_QUAD, "markDone" +

844

" id=IDX QUAD_VAL t=T_VAL [IDX] PT_VAL tEnd=T_VAL newWindSum=OPT newOppSum=OPT oppSum=OPT windSum=OPT windValue=IDX oppValue=OPT"

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

845

) || match_regexp(line, lineNo, record, MARK_DONE_CONIC, "markDone" +

846

" id=IDX CONIC_VAL t=T_VAL [IDX] PT_VAL tEnd=T_VAL newWindSum=OPT newOppSum=OPT oppSum=OPT windSum=OPT windValue=IDX oppValue=OPT"

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

847

) || match_regexp(line, lineNo, record, MARK_DONE_CUBIC, "markDone" +

848

" id=IDX CUBIC_VAL t=T_VAL [IDX] PT_VAL tEnd=T_VAL newWindSum=OPT newOppSum=OPT oppSum=OPT windSum=OPT windValue=IDX oppValue=OPT"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

849

) || match_regexp(line, lineNo, record, MARK_SIMPLE_LINE, "markWinding" +

850

" id=IDX LINE_VAL t=T_VAL [IDX] PT_VAL tEnd=T_VAL newWindSum=NUM windSum=OPT windValue=IDX"

851

) || match_regexp(line, lineNo, record, MARK_SIMPLE_QUAD, "markWinding" +

852

" id=IDX QUAD_VAL t=T_VAL [IDX] PT_VAL tEnd=T_VAL newWindSum=NUM windSum=OPT windValue=IDX"

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

853

) || match_regexp(line, lineNo, record, MARK_SIMPLE_CONIC, "markWinding" +

854

" id=IDX CONIC_VAL t=T_VAL [IDX] PT_VAL tEnd=T_VAL newWindSum=NUM windSum=OPT windValue=IDX"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

855

) || match_regexp(line, lineNo, record, MARK_SIMPLE_CUBIC, "markWinding" +

856

" id=IDX CUBIC_VAL t=T_VAL [IDX] PT_VAL tEnd=T_VAL newWindSum=NUM windSum=OPT windValue=IDX"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

857

) || match_regexp(line, lineNo, record, MARK_ANGLE_LAST, "markAngle" +

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

858

" last segment=IDX span=IDX"

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

859

) || match_regexp(line, lineNo, record, MARK_ANGLE_LAST, "markAngle" +

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

860

" last seg=IDX span=IDX"

861

) || match_regexp(line, lineNo, record, MARK_ANGLE_LAST, "markAngle" +

862

" last segment=IDX span=IDX windSum=OPT"

863

) || match_regexp(line, lineNo, record, MARK_ANGLE_LAST, "markAngle" +

864

" last seg=IDX span=IDX windSum=OPT"

865

);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

866

break;

867

case REC_TYPE_OP:

868

if (line.lastIndexOf("oppSign oppSign=", 0) === 0

869

|| line.lastIndexOf("operator<", 0) === 0) {

870

found = true;

871

break;

872

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

873

found = match_regexp(line, lineNo, record, OP_DIFFERENCE, "op diff"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

874

) || match_regexp(line, lineNo, record, OP_INTERSECT, "op intersect"

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

875

) || match_regexp(line, lineNo, record, OP_INTERSECT, "op sect"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

876

) || match_regexp(line, lineNo, record, OP_UNION, "op union"

877

) || match_regexp(line, lineNo, record, OP_XOR, "op xor"

878

);

879

break;

880

case REC_TYPE_UNKNOWN:

found = true;

break;

}

if (!found) {

console.log(line + " [" + lineNo + "] of type " + type + " not found");

886

}

887

}

888

if (recType != REC_TYPE_UNKNOWN) {

889

records.push(recType);

890

records.push(lastLineNo);

891

records.push(record);

892

}

893

if (records.length >= 1) {

894

tests[testIndex] = records;

895

testLines[testIndex] = lines;

}

}

function init(test) {

900

var canvas = document.getElementById('canvas');

901

if (!canvas.getContext) return;

902

ctx = canvas.getContext('2d');

903

var resScale = retina_scale && window.devicePixelRatio ? window.devicePixelRatio : 1;

904

var unscaledWidth = window.innerWidth - 20;

905

var unscaledHeight = window.innerHeight - 20;

906

screenWidth = unscaledWidth;

907

screenHeight = unscaledHeight;

908

canvas.width = unscaledWidth * resScale;

909

canvas.height = unscaledHeight * resScale;

910

canvas.style.width = unscaledWidth + 'px';

911

canvas.style.height = unscaledHeight + 'px';

912

if (resScale != 1) {

913

ctx.scale(resScale, resScale);

}

xmin = Infinity;

xmax = -Infinity;

ymin = Infinity;

ymax = -Infinity;

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

919

hasPath = hasAlignedPath = hasComputedPath = false;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

920

firstActiveSpan = -1;

921

for (var tIndex = 0; tIndex < test.length; tIndex += 3) {

922

var recType = test[tIndex];

923

if (!typeof recType == 'number' || recType < REC_TYPE_UNKNOWN || recType > REC_TYPE_LAST) {

924

console.log("unknown rec type: " + recType);

925

throw "stop execution";

926

}

927

var records = test[tIndex + 2];

928

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

929

var fragType = records[recordIndex];

930

if (!typeof fragType == 'number' || fragType < 1 || fragType > FRAG_TYPE_LAST) {

931

console.log("unknown in range frag type: " + fragType);

932

throw "stop execution";

933

}

934

var frags = records[recordIndex + 1];

var first = 0;

var last = -1;

var first2 = 0;

var last2 = 0;

switch (recType) {

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

940

case REC_TYPE_ALIGNED:

941

hasAlignedPath = true;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

942

case REC_TYPE_COMPUTED:

943

if (fragType == COMPUTED_SET_1 || fragType == COMPUTED_SET_2) {

944

break;

945

}

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

946

if (REC_TYPE_COMPUTED == recType) {

947

hasComputedPath = true;

948

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

949

case REC_TYPE_PATH:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

950

first = 1;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

951

switch (fragType) {

952

case PATH_LINE:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

953

last = 5;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

954

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

955

case PATH_CONIC:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

956

case PATH_QUAD:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

957

last = 7;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

958

break;

959

case PATH_CUBIC:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

960

last = 9;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

961

break;

962

default:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

963

console.log("unknown " + (recType == REC_TYPE_PATH ? "REC_TYPE_PATH"

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

964

: "REC_TYPE_COMPUTED") + " frag type:" + fragType);

965

throw "stop execution";

966

}

967

if (recType == REC_TYPE_PATH) {

968

hasPath = true;

969

}

970

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

case REC_TYPE_PATH2:

first = 1;

switch (fragType) {

case PATH_LINE:

last = 5;

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

977

case PATH_CONIC:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

case PATH_QUAD:

last = 7;

break;

case PATH_CUBIC:

last = 9;

break;

default:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

985

console.log("unknown " + (recType == REC_TYPE_PATH2 ? "REC_TYPE_PATH2"

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

986

: "REC_TYPE_COMPUTED") + " frag type:" + fragType);

987

throw "stop execution";

988

}

989

if (recType == REC_TYPE_PATH2) {

990

hasPath = true;

991

}

992

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

993

case REC_TYPE_ACTIVE:

994

if (firstActiveSpan < 0) {

995

firstActiveSpan = tIndex;

}

first = 1;

switch (fragType) {

case ACTIVE_LINE_SPAN:

1000

last = 5;

1001

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1002

case ACTIVE_CONIC_SPAN:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1003

case ACTIVE_QUAD_SPAN:

1004

last = 7;

1005

break;

1006

case ACTIVE_CUBIC_SPAN:

last = 9;

break;

default:

console.log("unknown REC_TYPE_ACTIVE frag type: " + fragType);

1011

throw "stop execution";

}

break;

case REC_TYPE_ADD:

switch (fragType) {

case ADD_MOVETO:

break;

case ADD_LINETO:

last = 4;

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1021

case ADD_CONICTO:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

case ADD_QUADTO:

last = 6;

break;

case ADD_CUBICTO:

last = 8;

break;

case ADD_CLOSE:

case ADD_FILL:

break;

default:

console.log("unknown REC_TYPE_ADD frag type: " + fragType);

1033

throw "stop execution";

1034

}

1035

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1036

case REC_TYPE_AFTERPART:

switch (fragType) {

case PATH_LINE:

last = 4;

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1041

case PATH_CONIC:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

case PATH_QUAD:

last = 6;

break;

case PATH_CUBIC:

last = 8;

break;

default:

console.log("unknown REC_TYPE_ACTIVEPART frag type: " + fragType);

1050

throw "stop execution";

1051

}

1052

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

case REC_TYPE_SECT:

switch (fragType) {

case INTERSECT_LINE:

first = 1; last = 5; first2 = 8; last2 = 12;

1057

break;

1058

case INTERSECT_LINE_2:

1059

first = 1; last = 5; first2 = 11; last2 = 15;

1060

break;

1061

case INTERSECT_LINE_NO:

1062

first = 0; last = 4; first2 = 4; last2 = 8;

1063

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1064

case INTERSECT_CONIC_LINE:

1065

first = 1; last = 7; first2 = 11; last2 = 15;

1066

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1067

case INTERSECT_QUAD_LINE:

1068

first = 1; last = 7; first2 = 10; last2 = 14;

1069

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1070

case INTERSECT_CONIC_LINE_2:

1071

first = 1; last = 7; first2 = 14; last2 = 18;

1072

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1073

case INTERSECT_QUAD_LINE_2:

1074

first = 1; last = 7; first2 = 13; last2 = 17;

1075

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1076

case INTERSECT_CONIC_LINE_NO:

1077

first = 0; last = 6; first2 = 7; last2 = 11;

1078

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1079

case INTERSECT_QUAD_LINE_NO:

1080

first = 0; last = 6; first2 = 6; last2 = 10;

1081

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1082

case INTERSECT_CONIC:

1083

first = 1; last = 7; first2 = 11; last2 = 17;

1084

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1085

case INTERSECT_QUAD:

1086

first = 1; last = 7; first2 = 10; last2 = 16;

1087

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1088

case INTERSECT_CONIC_2:

1089

first = 1; last = 7; first2 = 14; last2 = 20;

1090

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1091

case INTERSECT_QUAD_2:

1092

first = 1; last = 7; first2 = 13; last2 = 19;

1093

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1094

case INTERSECT_CONIC_NO:

1095

first = 0; last = 6; first2 = 7; last2 = 13;

1096

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1097

case INTERSECT_QUAD_NO:

1098

first = 0; last = 6; first2 = 6; last2 = 12;

1099

break;

1100

case INTERSECT_SELF_CUBIC:

1101

first = 1; last = 9;

1102

break;

1103

case INTERSECT_SELF_CUBIC_NO:

1104

first = 0; last = 8;

1105

break;

1106

case INTERSECT_CUBIC_LINE:

1107

first = 1; last = 9; first2 = 12; last2 = 16;

1108

break;

1109

case INTERSECT_CUBIC_LINE_2:

1110

first = 1; last = 9; first2 = 15; last2 = 19;

1111

break;

1112

case INTERSECT_CUBIC_LINE_3:

1113

first = 1; last = 9; first2 = 18; last2 = 22;

1114

break;

1115

case INTERSECT_CUBIC_LINE_NO:

1116

first = 0; last = 8; first2 = 8; last2 = 12;

1117

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

1118

case INTERSECT_CONIC_QUAD:

1119

first = 1; last = 7; first2 = 11; last2 = 17;

1120

break;

1121

case INTERSECT_CONIC_QUAD_2:

1122

first = 1; last = 7; first2 = 14; last2 = 20;

1123

break;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

1124

case INTERSECT_CONIC_QUAD_3:

1125

first = 1; last = 7; first2 = 17; last2 = 23;

1126

break;

1127

case INTERSECT_CONIC_QUAD_4:

1128

first = 1; last = 7; first2 = 20; last2 = 26;

1129

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

1130

case INTERSECT_CONIC_QUAD_NO:

1131

first = 0; last = 6; first2 = 7; last2 = 13;

1132

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1133

case INTERSECT_CUBIC_QUAD:

1134

first = 1; last = 9; first2 = 12; last2 = 18;

1135

break;

1136

case INTERSECT_CUBIC_QUAD_2:

1137

first = 1; last = 9; first2 = 15; last2 = 21;

1138

break;

1139

case INTERSECT_CUBIC_QUAD_3:

1140

first = 1; last = 9; first2 = 18; last2 = 24;

1141

break;

1142

case INTERSECT_CUBIC_QUAD_4:

1143

first = 1; last = 9; first2 = 21; last2 = 27;

1144

break;

1145

case INTERSECT_CUBIC_QUAD_NO:

1146

first = 0; last = 8; first2 = 8; last2 = 14;

1147

break;

1148

case INTERSECT_CUBIC:

1149

first = 1; last = 9; first2 = 12; last2 = 20;

1150

break;

1151

case INTERSECT_CUBIC_2:

1152

first = 1; last = 9; first2 = 15; last2 = 23;

1153

break;

1154

case INTERSECT_CUBIC_3:

1155

first = 1; last = 9; first2 = 18; last2 = 26;

1156

break;

1157

case INTERSECT_CUBIC_4:

1158

first = 1; last = 9; first2 = 21; last2 = 29;

1159

break;

1160

case INTERSECT_CUBIC_NO:

1161

first = 0; last = 8; first2 = 8; last2 = 16;

1162

break;

1163

default:

1164

console.log("unknown REC_TYPE_SECT frag type: " + fragType);

1165

throw "stop execution";

}

break;

default:

continue;

}

for (var idx = first; idx < last; idx += 2) {

1172

xmin = Math.min(xmin, frags[idx]);

1173

xmax = Math.max(xmax, frags[idx]);

1174

ymin = Math.min(ymin, frags[idx + 1]);

1175

ymax = Math.max(ymax, frags[idx + 1]);

1176

}

1177

for (var idx = first2; idx < last2; idx += 2) {

1178

xmin = Math.min(xmin, frags[idx]);

1179

xmax = Math.max(xmax, frags[idx]);

1180

ymin = Math.min(ymin, frags[idx + 1]);

1181

ymax = Math.max(ymax, frags[idx + 1]);

}

}

}

var angleBounds = [Infinity, Infinity, -Infinity, -Infinity];

1186

for (var tIndex = 0; tIndex < test.length; tIndex += 3) {

1187

var recType = test[tIndex];

1188

var records = test[tIndex + 2];

1189

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

1190

var fragType = records[recordIndex];

1191

var frags = records[recordIndex + 1];

1192

switch (recType) {

1193

case REC_TYPE_ACTIVE_OP:

if (!draw_op) {

break;

}

{

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

1199

curve_extremes(curve, angleBounds);

}

break;

case REC_TYPE_ANGLE:

if (!draw_angle) {

break;

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1206

{

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1207

var curve = curvePartialByID(test, frags[0], frags[4], frags[5]);

1208

curve_extremes(curve, angleBounds);

1209

curve = curvePartialByID(test, frags[6], frags[10], frags[11]);

1210

curve_extremes(curve, angleBounds);

1211

curve = curvePartialByID(test, frags[12], frags[16], frags[17]);

1212

}

1213

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

1214

case REC_TYPE_COINCIDENCE:

1215

if (!draw_coincidence) {

break;

}

{

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

1220

curve_extremes(curve, angleBounds);

1221

}

1222

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

case REC_TYPE_SORT:

if (!draw_sort) {

break;

}

if (fragType == SORT_UNARY || fragType == SORT_BINARY) {

1228

var curve = curvePartialByID(test, frags[0], frags[6], frags[8]);

1229

curve_extremes(curve, angleBounds);

1230

}

1231

break;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

case REC_TYPE_TOP:

if (!draw_top) {

break;

}

{

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

1238

curve_extremes(curve, angleBounds);

1239

}

1240

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

}

}

}

xmin = Math.min(xmin, angleBounds[0]);

1245

ymin = Math.min(ymin, angleBounds[1]);

1246

xmax = Math.max(xmax, angleBounds[2]);

1247

ymax = Math.max(ymax, angleBounds[3]);

1248

setScale(xmin, xmax, ymin, ymax);

1249

if (hasPath == false && hasComputedPath == true && !draw_computed) {

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1250

draw_computed = 7; // show quadratics, conics, and cubics

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1251

}

1252

if (hasPath == true && hasComputedPath == false && draw_computed) {

draw_computed = 0;

}

}

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

1257

function curveByIDMatch(test, id, recMatch) {

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1258

var tIndex = -3;

1259

while ((tIndex += 3) < test.length) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1260

var recType = test[tIndex];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1261

if (recType == REC_TYPE_OP) {

1262

continue;

1263

}

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

1264

if (recType != recMatch) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1265

return [];

1266

}

1267

var records = test[tIndex + 2];

1268

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

1269

var fragType = records[recordIndex];

1270

var frags = records[recordIndex + 1];

1271

if (frags[0] == id) {

1272

switch (fragType) {

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1273

case PATH_LINE:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1274

return [frags[1], frags[2], frags[3], frags[4]];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1275

case PATH_QUAD:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1276

return [frags[1], frags[2], frags[3], frags[4],

1277

frags[5], frags[6]];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1278

case PATH_CONIC:

1279

return [frags[1], frags[2], frags[3], frags[4],

1280

frags[5], frags[6], frags[7]];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1281

case PATH_CUBIC:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1282

return [frags[1], frags[2], frags[3], frags[4],

1283

frags[5], frags[6], frags[7], frags[8]];

1284

}

1285

}

1286

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

}

return [];

}

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

1291

function curveByID(test, id) {

1292

var result = draw_path >= 4 ? curveByIDMatch(test, id, REC_TYPE_ALIGNED) : [];

1293

if (!result.length) {

1294

result = curveByIDMatch(test, id, REC_TYPE_PATH);

}

return result;

}

function curvePartialByIDMatch(test, id, t0, t1, recMatch) {

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1300

var tIndex = -3;

1301

while ((tIndex += 3) < test.length) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1302

var recType = test[tIndex];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1303

if (recType == REC_TYPE_OP) {

1304

continue;

1305

}

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

1306

if (recType != recMatch) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1307

return [];

1308

}

1309

var records = test[tIndex + 2];

1310

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

1311

var fragType = records[recordIndex];

1312

var frags = records[recordIndex + 1];

1313

if (frags[0] == id) {

1314

switch (fragType) {

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1315

case PATH_LINE:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1316

return linePartial(frags[1], frags[2], frags[3], frags[4], t0, t1);

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1317

case PATH_QUAD:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1318

return quadPartial(frags[1], frags[2], frags[3], frags[4],

1319

frags[5], frags[6], t0, t1);

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1320

case PATH_CONIC:

1321

return conicPartial(frags[1], frags[2], frags[3], frags[4],

1322

frags[5], frags[6], frags[7], t0, t1);

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1323

case PATH_CUBIC:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1324

return cubicPartial(frags[1], frags[2], frags[3], frags[4],

1325

frags[5], frags[6], frags[7], frags[8], t0, t1);

1326

}

1327

}

1328

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

}

return [];

}

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

1333

function curvePartialByID(test, id, t0, t1) {

1334

var result = draw_path >= 4 ? curvePartialByIDMatch(test, id, t0, t1, REC_TYPE_ALIGNED) : [];

1335

if (!result.length) {

1336

result = curvePartialByIDMatch(test, id, t0, t1, REC_TYPE_PATH);

}

return result;

}

function idByCurveIDMatch(test, frag, type, recMatch) {

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1342

var tIndex = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1343

while (tIndex < test.length) {

1344

var recType = test[tIndex];

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

1345

if (recType != recMatch) {

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1346

++tIndex;

1347

continue;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1348

}

1349

var records = test[tIndex + 2];

1350

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

1351

var fragType = records[recordIndex];

1352

var frags = records[recordIndex + 1];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1353

if (frag.length != frags.length - 1) {

1354

continue;

1355

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1356

switch (fragType) {

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1357

case PATH_LINE:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1358

if (frag[0] != frags[1] || frag[1] != frags[2]

1359

|| frag[2] != frags[3] || frag[3] != frags[4]) {

1360

continue;

1361

}

1362

return frags[0];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1363

case PATH_QUAD:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1364

if (frag[0] != frags[1] || frag[1] != frags[2]

1365

|| frag[2] != frags[3] || frag[3] != frags[4]

1366

|| frag[4] != frags[5] || frag[5] != frags[6]) {

1367

continue;

1368

}

1369

return frags[0];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1370

case PATH_CONIC:

1371

if (frag[0] != frags[1] || frag[1] != frags[2]

1372

|| frag[2] != frags[3] || frag[3] != frags[4]

1373

|| frag[4] != frags[5] || frag[5] != frags[6]

1374

|| frag[6] != frags[7]) {

1375

continue;

1376

}

1377

return frags[0];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

1378

case PATH_CUBIC:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1379

if (frag[0] != frags[1] || frag[1] != frags[2]

1380

|| frag[2] != frags[3] || frag[3] != frags[4]

1381

|| frag[4] != frags[5] || frag[5] != frags[6]

1382

|| frag[6] != frags[7] || frag[7] != frags[8]) {

continue;

}

return frags[0];

}

}

++tIndex;

}

return -1;

}

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

1393

function idByCurve(test, frag, type) {

1394

var result = draw_path >= 4 ? idByCurveIDMatch(test, frag, type, REC_TYPE_ALIGNED) : [];

1395

if (!result.length) {

1396

result = idByCurveIDMatch(test, frag, type, REC_TYPE_PATH);

}

return result;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1401

function curve_extremes(curve, bounds) {

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1402

var length = curve.length == 7 ? 6 : curve.length;

caryclark

ed0935a

2015-10-22 07:23:52 -0700

[diff] [blame]

1403

for (var index = 0; index < length; index += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1404

var x = curve[index];

1405

var y = curve[index + 1];

1406

bounds[0] = Math.min(bounds[0], x);

1407

bounds[1] = Math.min(bounds[1], y);

1408

bounds[2] = Math.max(bounds[2], x);

1409

bounds[3] = Math.max(bounds[3], y);

}

}

function setScale(x0, x1, y0, y1) {

1414

var srcWidth = x1 - x0;

1415

var srcHeight = y1 - y0;

1416

var usableWidth = screenWidth;

1417

var xDigits = Math.ceil(Math.log(Math.abs(xmax)) / Math.log(10));

1418

var yDigits = Math.ceil(Math.log(Math.abs(ymax)) / Math.log(10));

1419

usableWidth -= (xDigits + yDigits) * 10;

1420

usableWidth -= decimal_places * 10;

if (draw_legend) {

usableWidth -= 40;

}

var hscale = usableWidth / srcWidth;

1425

var vscale = screenHeight / srcHeight;

1426

scale = Math.min(hscale, vscale);

1427

var invScale = 1 / scale;

1428

var sxmin = x0 - invScale * 5;

1429

var symin = y0 - invScale * 10;

1430

var sxmax = x1 + invScale * (6 * decimal_places + 10);

1431

var symax = y1 + invScale * 10;

1432

srcWidth = sxmax - sxmin;

1433

srcHeight = symax - symin;

1434

hscale = usableWidth / srcWidth;

1435

vscale = screenHeight / srcHeight;

1436

scale = Math.min(hscale, vscale);

srcLeft = sxmin;

srcTop = symin;

}

function drawArc(curve, op, from, to) {

1442

var type = PATH_LINE + (curve.length / 2 - 2);

1443

var pt = pointAtT(curve, type, op ? 0.4 : 0.6);

1444

var dy = pt.y - curve[1];

1445

var dx = pt.x - curve[0];

1446

var dist = Math.sqrt(dy * dy + dx * dx);

1447

var _dist = dist * scale;

1448

var angle = Math.atan2(dy, dx);

1449

var _px = (curve[0] - srcLeft) * scale;

1450

var _py = (curve[1] - srcTop) * scale;

var divisor = 4;

var endDist;

do {

var ends = [];

for (var index = -1; index <= 1; index += 2) {

1456

var px = Math.cos(index * Math.PI / divisor);

1457

var py = Math.sin(index * Math.PI / divisor);

ends.push(px);

ends.push(py);

}

var endDx = (ends[2] - ends[0]) * scale * dist;

1462

var endDy = (ends[3] - ends[1]) * scale * dist;

1463

endDist = Math.sqrt(endDx * endDx + endDy * endDy);

if (endDist < 100) {

break;

}

divisor *= 2;

} while (true);

if (endDist < 30) {

return;

}

if (op) {

divisor *= 2;

}

ctx.strokeStyle = op ? "rgba(210,0,45, 0.4)" : "rgba(90,90,90, 0.5)";

1476

ctx.beginPath();

1477

ctx.arc(_px, _py, _dist, angle - Math.PI / divisor, angle + Math.PI / divisor, false);

1478

ctx.stroke();

1479

var saveAlign = ctx.textAlign;

1480

var saveStyle = ctx.fillStyle;

1481

var saveFont = ctx.font;

1482

ctx.textAlign = "center";

1483

ctx.fillStyle = "black";

1484

ctx.font = "normal 24px Arial";

1485

divisor *= 0.8;

1486

for (var index = -1; index <= 1; index += 2) {

1487

var px = curve[0] + Math.cos(angle + index * Math.PI / divisor) * dist;

1488

var py = curve[1] + Math.sin(angle + index * Math.PI / divisor) * dist;

1489

var _px = (px - srcLeft) * scale;

1490

var _py = (py - srcTop) * scale;

1491

ctx.fillText(index < 0 ? to.toString() : from.toString(), _px, _py + 8);

1492

}

1493

ctx.textAlign = saveAlign;

1494

ctx.fillStyle = saveStyle;

ctx.font = saveFont;

}

function drawPoint(px, py, end) {

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1499

var length = drawnPts.length == 7 ? 6 : drawnPts.length;

1500

for (var pts = 0; pts < length; pts += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1501

var x = drawnPts[pts];

1502

var y = drawnPts[pts + 1];

1503

if (px == x && py == y) {

return;

}

}

drawnPts.push(px);

drawnPts.push(py);

var label = px.toFixed(decimal_places) + ", " + py.toFixed(decimal_places);

1510

var _px = (px - srcLeft) * scale;

1511

var _py = (py - srcTop) * scale;

1512

ctx.beginPath();

1513

ctx.arc(_px, _py, 3, 0, Math.PI*2, true);

ctx.closePath();

if (end) {

ctx.fill();

} else {

ctx.stroke();

}

if (debug_xy) {

ctx.textAlign = "left";

1522

ctx.fillText(label, _px + 5, _py);

}

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1526

function coordCount(curveType) {

switch (curveType) {

case PATH_LINE:

return 4;

case PATH_QUAD:

return 6;

case PATH_CONIC:

return 6;

case PATH_CUBIC:

return 8;

}

return -1;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1540

function drawPoints(ptArray, curveType, drawControls) {

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1541

var count = coordCount(curveType);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1542

for (var idx = 0; idx < count; idx += 2) {

1543

if (!drawControls && idx != 0 && idx != count - 2) {

1544

continue;

1545

}

1546

drawPoint(ptArray[idx], ptArray[idx + 1], idx == 0 || idx == count - 2);

}

}

function drawControlLines(curve, curveType, drawEnd) {

1551

if (curveType == PATH_LINE) {

1552

return;

1553

}

1554

ctx.strokeStyle = "rgba(0,0,0, 0.3)";

1555

drawLine(curve[0], curve[1], curve[2], curve[3]);

1556

drawLine(curve[2], curve[3], curve[4], curve[5]);

1557

if (curveType == PATH_CUBIC) {

1558

drawLine(curve[4], curve[5], curve[6], curve[7]);

1559

if (drawEnd > 1) {

1560

drawLine(curve[6], curve[7], curve[0], curve[1]);

1561

if (drawEnd > 2) {

1562

drawLine(curve[0], curve[1], curve[4], curve[5]);

1563

drawLine(curve[6], curve[7], curve[2], curve[3]);

1564

}

1565

}

1566

} else if (drawEnd > 1) {

1567

drawLine(curve[4], curve[5], curve[0], curve[1]);

}

}

function pointAtT(curve, curveType, t) {

var xy = {};

switch (curveType) {

case PATH_LINE:

var a = 1 - t;

var b = t;

xy.x = a * curve[0] + b * curve[2];

1578

xy.y = a * curve[1] + b * curve[3];

break;

case PATH_QUAD:

var one_t = 1 - t;

var a = one_t * one_t;

1583

var b = 2 * one_t * t;

1584

var c = t * t;

1585

xy.x = a * curve[0] + b * curve[2] + c * curve[4];

1586

xy.y = a * curve[1] + b * curve[3] + c * curve[5];

1587

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1588

case PATH_CONIC:

1589

var one_t = 1 - t;

1590

var a = one_t * one_t;

1591

var b = 2 * one_t * t;

1592

var c = t * t;

1593

xy.x = a * curve[0] + b * curve[2] * curve[6] + c * curve[4];

1594

xy.y = a * curve[1] + b * curve[3] * curve[6] + c * curve[5];

1595

var d = a + b * curve[6] + c;

1596

xy.x /= d;

1597

xy.y /= d;

1598

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1599

case PATH_CUBIC:

1600

var one_t = 1 - t;

1601

var one_t2 = one_t * one_t;

1602

var a = one_t2 * one_t;

1603

var b = 3 * one_t2 * t;

1604

var t2 = t * t;

1605

var c = 3 * one_t * t2;

1606

var d = t2 * t;

1607

xy.x = a * curve[0] + b * curve[2] + c * curve[4] + d * curve[6];

1608

xy.y = a * curve[1] + b * curve[3] + c * curve[5] + d * curve[7];

break;

}

return xy;

}

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

1613

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1614

function drawPointAtT(curve, curveType) {

1615

var x, y;

1616

var xy = pointAtT(curve, curveType, curveT);

1617

drawPoint(xy.x, xy.y, true);

1618

if (!draw_intersectT) {

1619

return;

1620

}

1621

ctx.fillStyle = "red";

1622

drawTAtPointUp(xy.x, xy.y, curveT);

1623

}

1624

1625

function drawTAtPointUp(px, py, t) {

1626

var label = t.toFixed(decimal_places);

1627

var _px = (px - srcLeft)* scale;

1628

var _py = (py - srcTop) * scale;

1629

ctx.fillText(label, _px + 5, _py - 10);

1630

}

1631

1632

function drawTAtPointDown(px, py, t) {

1633

var label = t.toFixed(decimal_places);

1634

var _px = (px - srcLeft)* scale;

1635

var _py = (py - srcTop) * scale;

1636

ctx.fillText(label, _px + 5, _py + 10);

1637

}

1638

1639

function alreadyDrawnLine(x1, y1, x2, y2) {

1640

if (collect_bounds) {

1641

if (focus_enabled) {

1642

focusXmin = Math.min(focusXmin, x1, x2);

1643

focusYmin = Math.min(focusYmin, y1, y2);

1644

focusXmax = Math.max(focusXmax, x1, x2);

1645

focusYmax = Math.max(focusYmax, y1, y2);

}

return true;

}

for (var pts = 0; pts < drawnLines.length; pts += 4) {

1650

if (x1 == drawnLines[pts] && y1 == drawnLines[pts + 1]

1651

&& x2 == drawnLines[pts + 2] && y2 == drawnLines[pts + 3]) {

return true;

}

}

drawnLines.push(x1);

drawnLines.push(y1);

drawnLines.push(x2);

drawnLines.push(y2);

return false;

}

function drawLine(x1, y1, x2, y2) {

1663

if (alreadyDrawnLine(x1, y1, x2, y2)) {

return;

}

ctx.beginPath();

ctx.moveTo((x1 - srcLeft) * scale,

1668

(y1 - srcTop) * scale);

1669

ctx.lineTo((x2 - srcLeft) * scale,

1670

(y2 - srcTop) * scale);

ctx.stroke();

}

function linePartial(x1, y1, x2, y2, t1, t2) {

var dx = x1 - x2;

var dy = y1 - y2;

var array = [

x1 - t1 * dx,

y1 - t1 * dy,

x1 - t2 * dx,

y1 - t2 * dy

];

return array;

}

function drawLinePartial(x1, y1, x2, y2, t1, t2) {

1687

var a = linePartial(x1, y1, x2, y2, t1, t2);

var ax = a[0];

var ay = a[1];

var bx = a[2];

var by = a[3];

if (alreadyDrawnLine(ax, ay, bx, by)) {

return;

}

ctx.beginPath();

ctx.moveTo((ax - srcLeft) * scale,

1697

(ay - srcTop) * scale);

1698

ctx.lineTo((bx - srcLeft) * scale,

1699

(by - srcTop) * scale);

ctx.stroke();

}

function alreadyDrawnQuad(x1, y1, x2, y2, x3, y3) {

1704

if (collect_bounds) {

1705

if (focus_enabled) {

1706

focusXmin = Math.min(focusXmin, x1, x2, x3);

1707

focusYmin = Math.min(focusYmin, y1, y2, y3);

1708

focusXmax = Math.max(focusXmax, x1, x2, x3);

1709

focusYmax = Math.max(focusYmax, y1, y2, y3);

}

return true;

}

for (var pts = 0; pts < drawnQuads.length; pts += 6) {

1714

if (x1 == drawnQuads[pts] && y1 == drawnQuads[pts + 1]

1715

&& x2 == drawnQuads[pts + 2] && y2 == drawnQuads[pts + 3]

1716

&& x3 == drawnQuads[pts + 4] && y3 == drawnQuads[pts + 5]) {

return true;

}

}

drawnQuads.push(x1);

drawnQuads.push(y1);

drawnQuads.push(x2);

drawnQuads.push(y2);

drawnQuads.push(x3);

drawnQuads.push(y3);

return false;

}

function drawQuad(x1, y1, x2, y2, x3, y3) {

1730

if (alreadyDrawnQuad(x1, y1, x2, y2, x3, y3)) {

return;

}

ctx.beginPath();

ctx.moveTo((x1 - srcLeft) * scale,

1735

(y1 - srcTop) * scale);

1736

ctx.quadraticCurveTo((x2 - srcLeft) * scale,

1737

(y2 - srcTop) * scale,

1738

(x3 - srcLeft) * scale,

1739

(y3 - srcTop) * scale);

ctx.stroke();

}

function interp(A, B, t) {

1744

return A + (B - A) * t;

1745

}

1746

1747

function interp_quad_coords(x1, x2, x3, t)

1748

{

1749

var ab = interp(x1, x2, t);

1750

var bc = interp(x2, x3, t);

1751

var abc = interp(ab, bc, t);

return abc;

}

function quadPartial(x1, y1, x2, y2, x3, y3, t1, t2) {

1756

var ax = interp_quad_coords(x1, x2, x3, t1);

1757

var ay = interp_quad_coords(y1, y2, y3, t1);

1758

var dx = interp_quad_coords(x1, x2, x3, (t1 + t2) / 2);

1759

var dy = interp_quad_coords(y1, y2, y3, (t1 + t2) / 2);

1760

var cx = interp_quad_coords(x1, x2, x3, t2);

1761

var cy = interp_quad_coords(y1, y2, y3, t2);

1762

var bx = 2*dx - (ax + cx)/2;

1763

var by = 2*dy - (ay + cy)/2;

1764

var array = [

1765

ax, ay, bx, by, cx, cy

];

return array;

}

function drawQuadPartial(x1, y1, x2, y2, x3, y3, t1, t2) {

1771

var a = quadPartial(x1, y1, x2, y2, x3, y3, t1, t2);

var ax = a[0];

var ay = a[1];

var bx = a[2];

var by = a[3];

var cx = a[4];

var cy = a[5];

if (alreadyDrawnQuad(ax, ay, bx, by, cx, cy)) {

return;

}

ctx.beginPath();

ctx.moveTo((ax - srcLeft) * scale,

1783

(ay - srcTop) * scale);

1784

ctx.quadraticCurveTo((bx - srcLeft) * scale,

1785

(by - srcTop) * scale,

1786

(cx - srcLeft) * scale,

1787

(cy - srcTop) * scale);

ctx.stroke();

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1791

function alreadyDrawnConic(x1, y1, x2, y2, x3, y3, w) {

1792

if (collect_bounds) {

1793

if (focus_enabled) {

1794

focusXmin = Math.min(focusXmin, x1, x2, x3);

1795

focusYmin = Math.min(focusYmin, y1, y2, y3);

1796

focusXmax = Math.max(focusXmax, x1, x2, x3);

1797

focusYmax = Math.max(focusYmax, y1, y2, y3);

}

return true;

}

for (var pts = 0; pts < drawnConics.length; pts += 8) {

1802

if (x1 == drawnConics[pts] && y1 == drawnCubics[pts + 1]

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

1803

&& x2 == drawnCubics[pts + 2] && y2 == drawnCubics[pts + 3]

1804

&& x3 == drawnCubics[pts + 4] && y3 == drawnCubics[pts + 5]

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1805

&& w == drawnCubics[pts + 6]) {

return true;

}

}

drawnConics.push(x1);

1810

drawnConics.push(y1);

1811

drawnConics.push(x2);

1812

drawnConics.push(y2);

1813

drawnConics.push(x3);

1814

drawnConics.push(y3);

drawnCubics.push(w);

return false;

}

var kMaxConicToQuadPOW2 = 5;

1820

1821

function computeQuadPOW2(curve, tol) {

1822

var a = curve[6] - 1;

1823

var k = a / (4 * (2 + a));

1824

var x = k * (curve[0] - 2 * curve[2] + curve[4]);

1825

var y = k * (curve[1] - 2 * curve[3] + curve[5]);

1826

1827

var error = Math.sqrt(x * x + y * y);

1828

var pow2;

1829

for (pow2 = 0; pow2 < kMaxConicToQuadPOW2; ++pow2) {

if (error <= tol) {

break;

}

error *= 0.25;

}

return pow2;

}

function subdivide_w_value(w) {

1839

return Math.sqrt(0.5 + w * 0.5);

1840

}

1841

1842

function chop(curve, part1, part2) {

1843

var w = curve[6];

1844

var scale = 1 / (1 + w);

1845

part1[0] = curve[0];

1846

part1[1] = curve[1];

1847

part1[2] = (curve[0] + curve[2] * w) * scale;

1848

part1[3] = (curve[1] + curve[3] * w) * scale;

1849

part1[4] = part2[0] = (curve[0] + (curve[2] * w) * 2 + curve[4]) * scale * 0.5;

1850

part1[5] = part2[1] = (curve[1] + (curve[3] * w) * 2 + curve[5]) * scale * 0.5;

1851

part2[2] = (curve[2] * w + curve[4]) * scale;

1852

part2[3] = (curve[3] * w + curve[5]) * scale;

1853

part2[4] = curve[4];

1854

part2[5] = curve[5];

1855

part1[6] = part2[6] = subdivide_w_value(w);

1856

}

1857

1858

function subdivide(curve, level, pts) {

if (0 == level) {

pts.push(curve[2]);

pts.push(curve[3]);

pts.push(curve[4]);

pts.push(curve[5]);

} else {

var part1 = [], part2 = [];

1866

chop(curve, part1, part2);

1867

--level;

1868

subdivide(part1, level, pts);

1869

subdivide(part2, level, pts);

}

}

function chopIntoQuadsPOW2(curve, pow2, pts) {

1874

subdivide(curve, pow2, pts);

return 1 << pow2;

}

function drawConicWithQuads(x1, y1, x2, y2, x3, y3, w) {

1879

if (alreadyDrawnConic(x1, y1, x2, y2, x3, y3, w)) {

return;

}

ctx.beginPath();

ctx.moveTo((x1 - srcLeft) * scale,

1884

(y1 - srcTop) * scale);

1885

var tol = 1 / scale;

1886

var curve = [x1, y1, x2, y2, x3, y3, w];

1887

var pow2 = computeQuadPOW2(curve, tol);

1888

var pts = [];

1889

chopIntoQuadsPOW2(curve, pow2, pts);

1890

for (var i = 0; i < pts.length; i += 4) {

1891

ctx.quadraticCurveTo(

1892

(pts[i + 0] - srcLeft) * scale, (pts[i + 1] - srcTop) * scale,

1893

(pts[i + 2] - srcLeft) * scale, (pts[i + 3] - srcTop) * scale);

}

ctx.stroke();

}

function conic_eval_numerator(x1, x2, x3, w, t) {

1899

var src2w = x2 * w;

1900

var C = x1;

1901

var A = x3 - 2 * src2w + C;

1902

var B = 2 * (src2w - C);

1903

return (A * t + B) * t + C;

}

function conic_eval_denominator(w, t) {

var B = 2 * (w - 1);

var C = 1;

var A = -B;

return (A * t + B) * t + C;

1912

}

1913

1914

function conicPartial(x1, y1, x2, y2, x3, y3, w, t1, t2) {

1915

var ax = conic_eval_numerator(x1, x2, x3, w, t1);

1916

var ay = conic_eval_numerator(y1, y2, y3, w, t1);

1917

var az = conic_eval_denominator(w, t1);

1918

var midT = (t1 + t2) / 2;

1919

var dx = conic_eval_numerator(x1, x2, x3, w, midT);

1920

var dy = conic_eval_numerator(y1, y2, y3, w, midT);

1921

var dz = conic_eval_denominator(w, midT);

1922

var cx = conic_eval_numerator(x1, x2, x3, w, t2);

1923

var cy = conic_eval_numerator(y1, y2, y3, w, t2);

1924

var cz = conic_eval_denominator(w, t2);

1925

var bx = 2 * dx - (ax + cx) / 2;

1926

var by = 2 * dy - (ay + cy) / 2;

1927

var bz = 2 * dz - (az + cz) / 2;

1928

var dt = t2 - t1;

1929

var dt_1 = 1 - dt;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1930

var array = [

caryclark

ed0935a

2015-10-22 07:23:52 -0700

[diff] [blame]

1931

ax / az, ay / az, bx / bz, by / bz, cx / cz, cy / cz, 0

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1932

];

caryclark

ed0935a

2015-10-22 07:23:52 -0700

[diff] [blame]

1933

var dMidAC = { x:(array[0] + array[4]) / 2, y:(array[1] + array[5]) / 2 };

1934

var dMid = { x:dx / dz, y:dy / dz };

1935

var dWNumer = { x:dMidAC.x - dMid.x, y:dMidAC.y - dMid.y };

1936

var dWDenom = { x:dMid.x - array[2], y:dMid.y - array[3] };

1937

var partW = Math.sqrt(dWNumer.x * dWNumer.x + dWNumer.y * dWNumer.y)

1938

/ Math.sqrt(dWDenom.x * dWDenom.x + dWDenom.y * dWDenom.y);

1939

array[6] = partW;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1940

return array;

1941

}

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

1942

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1943

function drawConicPartial(x1, y1, x2, y2, x3, y3, w, t1, t2) {

1944

var a = conicPartial(x1, y1, x2, y2, x3, y3, w, t1, t2);

var ax = a[0];

var ay = a[1];

var bx = a[2];

var by = a[3];

var cx = a[4];

var cy = a[5];

var w_ = a[6];

drawConicWithQuads(ax, ay, bx, by, cx, cy, w_);

1953

}

1954

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1955

function alreadyDrawnCubic(x1, y1, x2, y2, x3, y3, x4, y4) {

1956

if (collect_bounds) {

1957

if (focus_enabled) {

1958

focusXmin = Math.min(focusXmin, x1, x2, x3, x4);

1959

focusYmin = Math.min(focusYmin, y1, y2, y3, y4);

1960

focusXmax = Math.max(focusXmax, x1, x2, x3, x4);

1961

focusYmax = Math.max(focusYmax, y1, y2, y3, y4);

}

return true;

}

for (var pts = 0; pts < drawnCubics.length; pts += 8) {

1966

if (x1 == drawnCubics[pts] && y1 == drawnCubics[pts + 1]

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

1967

&& x2 == drawnCubics[pts + 2] && y2 == drawnCubics[pts + 3]

1968

&& x3 == drawnCubics[pts + 4] && y3 == drawnCubics[pts + 5]

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1969

&& x4 == drawnCubics[pts + 6] && y4 == drawnCubics[pts + 7]) {

return true;

}

}

drawnCubics.push(x1);

1974

drawnCubics.push(y1);

1975

drawnCubics.push(x2);

1976

drawnCubics.push(y2);

1977

drawnCubics.push(x3);

1978

drawnCubics.push(y3);

1979

drawnCubics.push(x4);

1980

drawnCubics.push(y4);

return false;

}

function drawCubic(x1, y1, x2, y2, x3, y3, x4, y4) {

1985

if (alreadyDrawnCubic(x1, y1, x2, y2, x3, y3, x4, y4)) {

return;

}

ctx.beginPath();

ctx.moveTo((x1 - srcLeft) * scale,

1990

(y1 - srcTop) * scale);

1991

ctx.bezierCurveTo((x2 - srcLeft) * scale,

1992

(y2 - srcTop) * scale,

1993

(x3 - srcLeft) * scale,

1994

(y3 - srcTop) * scale,

1995

(x4 - srcLeft) * scale,

1996

(y4 - srcTop) * scale);

ctx.stroke();

}

function interp_cubic_coords(x1, x2, x3, x4, t)

2001

{

2002

var ab = interp(x1, x2, t);

2003

var bc = interp(x2, x3, t);

2004

var cd = interp(x3, x4, t);

2005

var abc = interp(ab, bc, t);

2006

var bcd = interp(bc, cd, t);

2007

var abcd = interp(abc, bcd, t);

return abcd;

}

function cubicPartial(x1, y1, x2, y2, x3, y3, x4, y4, t1, t2) {

2012

var ax = interp_cubic_coords(x1, x2, x3, x4, t1);

2013

var ay = interp_cubic_coords(y1, y2, y3, y4, t1);

2014

var ex = interp_cubic_coords(x1, x2, x3, x4, (t1*2+t2)/3);

2015

var ey = interp_cubic_coords(y1, y2, y3, y4, (t1*2+t2)/3);

2016

var fx = interp_cubic_coords(x1, x2, x3, x4, (t1+t2*2)/3);

2017

var fy = interp_cubic_coords(y1, y2, y3, y4, (t1+t2*2)/3);

2018

var dx = interp_cubic_coords(x1, x2, x3, x4, t2);

2019

var dy = interp_cubic_coords(y1, y2, y3, y4, t2);

2020

var mx = ex * 27 - ax * 8 - dx;

2021

var my = ey * 27 - ay * 8 - dy;

2022

var nx = fx * 27 - ax - dx * 8;

2023

var ny = fy * 27 - ay - dy * 8;

2024

var bx = (mx * 2 - nx) / 18;

2025

var by = (my * 2 - ny) / 18;

2026

var cx = (nx * 2 - mx) / 18;

2027

var cy = (ny * 2 - my) / 18;

2028

var array = [

2029

ax, ay, bx, by, cx, cy, dx, dy

2030

];

2031

return array;

2032

}

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2033

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2034

function drawCubicPartial(x1, y1, x2, y2, x3, y3, x4, y4, t1, t2) {

2035

var a = cubicPartial(x1, y1, x2, y2, x3, y3, x4, y4, t1, t2);

var ax = a[0];

var ay = a[1];

var bx = a[2];

var by = a[3];

var cx = a[4];

var cy = a[5];

var dx = a[6];

var dy = a[7];

if (alreadyDrawnCubic(ax, ay, bx, by, cx, cy, dx, dy)) {

return;

}

ctx.beginPath();

ctx.moveTo((ax - srcLeft) * scale,

2049

(ay - srcTop) * scale);

2050

ctx.bezierCurveTo((bx - srcLeft) * scale,

2051

(by - srcTop) * scale,

2052

(cx - srcLeft) * scale,

2053

(cy - srcTop) * scale,

2054

(dx - srcLeft) * scale,

2055

(dy - srcTop) * scale);

ctx.stroke();

}

function drawCurve(c) {

2060

switch (c.length) {

2061

case 4:

2062

drawLine(c[0], c[1], c[2], c[3]);

2063

break;

2064

case 6:

2065

drawQuad(c[0], c[1], c[2], c[3], c[4], c[5]);

2066

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2067

case 7:

2068

drawConicWithQuads(c[0], c[1], c[2], c[3], c[4], c[5], c[6]);

2069

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2070

case 8:

2071

drawCubic(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]);

break;

}

}

function boundsWidth(pts) {

2077

var min = pts[0];

2078

var max = pts[0];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2079

var length = pts.length == 7 ? 6 : pts.length;

2080

for (var idx = 2; idx < length; idx += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2081

min = Math.min(min, pts[idx]);

2082

max = Math.max(max, pts[idx]);

}

return max - min;

}

function boundsHeight(pts) {

2088

var min = pts[1];

2089

var max = pts[1];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2090

var length = pts.length == 7 ? 6 : pts.length;

2091

for (var idx = 3; idx < length; idx += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2092

min = Math.min(min, pts[idx]);

2093

max = Math.max(max, pts[idx]);

}

return max - min;

}

function tangent(pts) {

2099

var dx = pts[2] - pts[0];

2100

var dy = pts[3] - pts[1];

2101

if (dx == 0 && dy == 0 && pts.length > 4) {

2102

dx = pts[4] - pts[0];

2103

dy = pts[5] - pts[1];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2104

if (dx == 0 && dy == 0 && pts.length == 8) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2105

dx = pts[6] - pts[0];

2106

dy = pts[7] - pts[1];

2107

}

2108

}

2109

return Math.atan2(-dy, dx);

2110

}

2111

2112

function hodograph(cubic) {

2113

var hodo = [];

2114

hodo[0] = 3 * (cubic[2] - cubic[0]);

2115

hodo[1] = 3 * (cubic[3] - cubic[1]);

2116

hodo[2] = 3 * (cubic[4] - cubic[2]);

2117

hodo[3] = 3 * (cubic[5] - cubic[3]);

2118

hodo[4] = 3 * (cubic[6] - cubic[4]);

2119

hodo[5] = 3 * (cubic[7] - cubic[5]);

return hodo;

}

function hodograph2(cubic) {

2124

var quad = hodograph(cubic);

2125

var hodo = [];

2126

hodo[0] = 2 * (quad[2] - quad[0]);

2127

hodo[1] = 2 * (quad[3] - quad[1]);

2128

hodo[2] = 2 * (quad[4] - quad[2]);

2129

hodo[3] = 2 * (quad[5] - quad[3]);

return hodo;

}

function quadraticRootsReal(A, B, C, s) {

if (A == 0) {

if (B == 0) {

s[0] = 0;

return C == 0;

}

s[0] = -C / B;

return 1;

}

/* normal form: x^2 + px + q = 0 */

var p = B / (2 * A);

var q = C / A;

var p2 = p * p;

if (p2 < q) {

return 0;

}

var sqrt_D = 0;

if (p2 > q) {

sqrt_D = sqrt(p2 - q);

}

s[0] = sqrt_D - p;

s[1] = -sqrt_D - p;

return 1 + s[0] != s[1];

2156

}

2157

2158

function add_valid_ts(s, realRoots, t) {

2159

var foundRoots = 0;

2160

for (var index = 0; index < realRoots; ++index) {

2161

var tValue = s[index];

2162

if (tValue >= 0 && tValue <= 1) {

2163

for (var idx2 = 0; idx2 < foundRoots; ++idx2) {

2164

if (t[idx2] != tValue) {

2165

t[foundRoots++] = tValue;

}

}

}

}

return foundRoots;

}

function quadraticRootsValidT(a, b, c, t) {

2174

var s = [];

2175

var realRoots = quadraticRootsReal(A, B, C, s);

2176

var foundRoots = add_valid_ts(s, realRoots, t);

2177

return foundRoots != 0;

2178

}

2179

2180

function find_cubic_inflections(cubic, tValues) {

2181

var Ax = src[2] - src[0];

2182

var Ay = src[3] - src[1];

2183

var Bx = src[4] - 2 * src[2] + src[0];

2184

var By = src[5] - 2 * src[3] + src[1];

2185

var Cx = src[6] + 3 * (src[2] - src[4]) - src[0];

2186

var Cy = src[7] + 3 * (src[3] - src[5]) - src[1];

2187

return quadraticRootsValidT(Bx * Cy - By * Cx, (Ax * Cy - Ay * Cx),

2188

Ax * By - Ay * Bx, tValues);

2189

}

2190

2191

function dxy_at_t(curve, type, t) {

2192

var dxy = {};

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2193

if (type == PATH_LINE) {

2194

dxy.x = curve[2] - curve[0];

2195

dxy.y = curve[3] - curve[1];

2196

} else if (type == PATH_QUAD) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

var a = t - 1;

var b = 1 - 2 * t;

var c = t;

dxy.x = a * curve[0] + b * curve[2] + c * curve[4];

2201

dxy.y = a * curve[1] + b * curve[3] + c * curve[5];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2202

} else if (type == PATH_CONIC) {

2203

var p20x = curve[4] - curve[0];

2204

var p20y = curve[5] - curve[1];

2205

var p10xw = (curve[2] - curve[0]) * curve[6];

2206

var p10yw = (curve[3] - curve[1]) * curve[6];

2207

var coeff0x = curve[6] * p20x - p20x;

2208

var coeff0y = curve[6] * p20y - p20y;

2209

var coeff1x = p20x - 2 * p10xw;

2210

var coeff1y = p20y - 2 * p10yw;

2211

dxy.x = t * (t * coeff0x + coeff1x) + p10xw;

2212

dxy.y = t * (t * coeff0y + coeff1y) + p10yw;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2213

} else if (type == PATH_CUBIC) {

var one_t = 1 - t;

var a = curve[0];

var b = curve[2];

var c = curve[4];

var d = curve[6];

dxy.x = 3 * ((b - a) * one_t * one_t + 2 * (c - b) * t * one_t + (d - c) * t * t);

a = curve[1];

b = curve[3];

c = curve[5];

d = curve[7];

dxy.y = 3 * ((b - a) * one_t * one_t + 2 * (c - b) * t * one_t + (d - c) * t * t);

}

return dxy;

}

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2229

function dpt_at_t(curve, t) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2230

var type = PATH_LINE + (curve.length / 2 - 2);

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2231

return dxy_at_t(curve, type, t);

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2232

}

2233

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2234

function drawLabel(num, px, py) {

2235

ctx.beginPath();

2236

ctx.arc(px, py, 8, 0, Math.PI*2, true);

2237

ctx.closePath();

2238

ctx.strokeStyle = "rgba(0,0,0, 0.4)";

2239

ctx.lineWidth = num == 0 || num == 3 ? 2 : 1;

2240

ctx.stroke();

2241

ctx.fillStyle = "black";

2242

ctx.font = "normal 10px Arial";

2243

// ctx.rotate(0.001);

2244

ctx.fillText(num, px - 2, py + 3);

2245

// ctx.rotate(-0.001);

2246

}

2247

2248

function drawLabelX(ymin, num, loc) {

2249

var px = (loc - srcLeft) * scale;

2250

var py = (ymin - srcTop) * scale - 20;

2251

drawLabel(num, px, py);

2252

}

2253

2254

function drawLabelY(xmin, num, loc) {

2255

var px = (xmin - srcLeft) * scale - 20;

2256

var py = (loc - srcTop) * scale;

2257

drawLabel(num, px, py);

2258

}

2259

2260

function drawHodoOrigin(hx, hy, hMinX, hMinY, hMaxX, hMaxY) {

2261

ctx.beginPath();

2262

ctx.moveTo(hx, hy - 100);

2263

ctx.lineTo(hx, hy);

2264

ctx.strokeStyle = hMinY < 0 ? "green" : "blue";

ctx.stroke();

ctx.beginPath();

ctx.moveTo(hx, hy);

ctx.lineTo(hx, hy + 100);

2269

ctx.strokeStyle = hMaxY > 0 ? "green" : "blue";

2270

ctx.stroke();

2271

ctx.beginPath();

2272

ctx.moveTo(hx - 100, hy);

2273

ctx.lineTo(hx, hy);

2274

ctx.strokeStyle = hMinX < 0 ? "green" : "blue";

ctx.stroke();

ctx.beginPath();

ctx.moveTo(hx, hy);

ctx.lineTo(hx + 100, hy);

2279

ctx.strokeStyle = hMaxX > 0 ? "green" : "blue";

ctx.stroke();

}

function scalexy(x, y, mag) {

2284

var length = Math.sqrt(x * x + y * y);

return mag / length;

}

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2288

function drawArrow(x, y, dx, dy, s) {

2289

var dscale = scalexy(dx, dy, 1 / scale * 100 * s);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

dx *= dscale;

dy *= dscale;

ctx.beginPath();

ctx.moveTo((x - srcLeft) * scale, (y - srcTop) * scale);

2294

x += dx;

2295

y += dy;

2296

ctx.lineTo((x - srcLeft) * scale, (y - srcTop) * scale);

2297

dx /= 10;

2298

dy /= 10;

2299

ctx.lineTo((x - dy - srcLeft) * scale, (y + dx - srcTop) * scale);

2300

ctx.lineTo((x + dx * 2 - srcLeft) * scale, (y + dy * 2 - srcTop) * scale);

2301

ctx.lineTo((x + dy - srcLeft) * scale, (y - dx - srcTop) * scale);

2302

ctx.lineTo((x - srcLeft) * scale, (y - srcTop) * scale);

2303

ctx.strokeStyle = "rgba(0,75,0, 0.4)";

ctx.stroke();

}

function x_at_t(curve, t) {

2308

var one_t = 1 - t;

2309

if (curve.length == 4) {

2310

return one_t * curve[0] + t * curve[2];

2311

}

2312

var one_t2 = one_t * one_t;

2313

var t2 = t * t;

2314

if (curve.length == 6) {

2315

return one_t2 * curve[0] + 2 * one_t * t * curve[2] + t2 * curve[4];

2316

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2317

if (curve.length == 7) {

2318

return (one_t2 * curve[0] + 2 * one_t * t * curve[2] * curve[6] + t2 * curve[4])

2319

/ (one_t2 +2 * one_t * t * curve[6] + t2);

2320

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2321

var a = one_t2 * one_t;

2322

var b = 3 * one_t2 * t;

2323

var c = 3 * one_t * t2;

2324

var d = t2 * t;

2325

return a * curve[0] + b * curve[2] + c * curve[4] + d * curve[6];

2326

}

2327

2328

function y_at_t(curve, t) {

2329

var one_t = 1 - t;

2330

if (curve.length == 4) {

2331

return one_t * curve[1] + t * curve[3];

2332

}

2333

var one_t2 = one_t * one_t;

2334

var t2 = t * t;

2335

if (curve.length == 6) {

2336

return one_t2 * curve[1] + 2 * one_t * t * curve[3] + t2 * curve[5];

2337

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2338

if (curve.length == 7) {

2339

return (one_t2 * curve[1] + 2 * one_t * t * curve[3] * curve[6] + t2 * curve[5])

2340

/ (one_t2 +2 * one_t * t * curve[6] + t2);

2341

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2342

var a = one_t2 * one_t;

2343

var b = 3 * one_t2 * t;

2344

var c = 3 * one_t * t2;

2345

var d = t2 * t;

2346

return a * curve[1] + b * curve[3] + c * curve[5] + d * curve[7];

2347

}

2348

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2349

function pt_at_t(curve, t) {

2350

var pt = {};

2351

pt.x = x_at_t(curve, t);

2352

pt.y = y_at_t(curve, t);

2353

return pt;

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2354

}

2355

2356

function drawOrder(curve, t, label) {

2357

var px = x_at_t(curve, t);

2358

var py = y_at_t(curve, t);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2359

var _px = (px - srcLeft) * scale;

2360

var _py = (py - srcTop) * scale;

2361

ctx.beginPath();

2362

ctx.arc(_px, _py, 15, 0, Math.PI * 2, true);

2363

ctx.closePath();

2364

ctx.fillStyle = "white";

2365

ctx.fill();

2366

if (label == 'L') {

2367

ctx.strokeStyle = "rgba(255,0,0, 1)";

2368

ctx.fillStyle = "rgba(255,0,0, 1)";

2369

} else {

2370

ctx.strokeStyle = "rgba(0,0,255, 1)";

2371

ctx.fillStyle = "rgba(0,0,255, 1)";

2372

}

2373

ctx.stroke();

2374

ctx.font = "normal 16px Arial";

2375

ctx.textAlign = "center";

2376

ctx.fillText(label, _px, _py + 5);

2377

ctx.font = "normal 10px Arial";

2378

}

2379

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2380

function drawVisibleOrder(curve, label) {

2381

var s = pt_at_t(curve, 0);

2382

var e = pt_at_t(curve, 1);

2383

var sOn = ptOnScreen(s);

2384

var eOn = ptOnScreen(e);

2385

var defaultT = 0.85;

2386

if (sOn && eOn)

2387

return drawOrder(curve, defaultT, label);

2388

if (sOn || eOn) {

2389

if (eOn) {

2390

defaultT = 1 - defaultT;

2391

}

2392

var step = sOn ? -defaultT / 2 : (1 - defaultT) / 2;

var t = defaultT;

var tries = 16;

do {

var mid = pt_at_t(curve, t);

2397

if (ptOnScreen(mid))

2398

return drawOrder(curve, t, label);

2399

t += step;

2400

step /= 2;

2401

} while (--tries > 0);

2402

drawOrder(curve, defaultT, label);

2403

}

2404

// scattershot until we find a visible point

2405

var denom = 2; // visit odd number num / denom to hit unique pts

2406

var tries = 6; // tries 1/2, 1/4, 3/4, 1/8, 3/8, 5/8, 7/8, 1/16 ...

2407

do {

2408

for (var numer = 1; numer < denom; numer += 2) {

2409

var t = numer / denom + 0.1;

if (t >= 1) {

break;

}

var mid = pt_at_t(curve, t);

2414

if (ptOnScreen(mid))

2415

return drawOrder(curve, t, label);

2416

}

2417

denom *= 2;

2418

} while (--tries > 0);

2419

drawOrder(curve, defaultT, label);

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2420

}

2421

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2422

function set_length(pt, newLen) {

2423

var len = Math.sqrt(pt.x * pt.x + pt.y * pt.y);

2424

var scale = newLen / len;

2425

var newPt = { x: pt.x * scale, y: pt.y * scale };

2426

return newPt;

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2427

}

2428

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2429

function drawDirection(curve, t) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2430

var d = dpt_at_t(curve, t);

2431

d = set_length(d, 16);

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2432

var pt = localToGlobal(pt_at_t(curve, t));

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2433

ctx.beginPath();

2434

ctx.moveTo(pt.x - d.y, pt.y + d.x);

2435

ctx.lineTo(pt.x + d.x, pt.y + d.y);

2436

ctx.lineTo(pt.x + d.y, pt.y - d.x);

2437

ctx.strokeStyle = "rgba(0,75,0, 0.4)";

ctx.stroke();

}

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2441

function drawVisibleDirection(curve) {

2442

var s = pt_at_t(curve, 0);

2443

var e = pt_at_t(curve, 1);

2444

var sOn = ptOnScreen(s);

2445

var eOn = ptOnScreen(e);

2446

var defaultT = 0.65;

2447

if (sOn && eOn) {

2448

return drawDirection(curve, defaultT);

}

if (sOn || eOn) {

if (eOn) {

defaultT = 1 - defaultT;

2453

}

2454

var step = sOn ? -defaultT / 2 : (1 - defaultT) / 2;

var t = defaultT;

var tries = 16;

do {

var mid = pt_at_t(curve, t);

2459

if (ptOnScreen(mid))

2460

return drawDirection(curve, t);

2461

t += step;

2462

step /= 2;

2463

} while (--tries > 0);

2464

drawDirection(curve, defaultT);

2465

}

2466

// scattershot until we find a visible point

2467

var denom = 2; // visit odd number num / denom to hit unique pts

2468

var tries = 6; // tries 1/2, 1/4, 3/4, 1/8, 3/8, 5/8, 7/8, 1/16 ...

2469

do {

2470

for (var numer = 1; numer < denom; numer += 2) {

2471

var t = numer / denom + 0.1;

if (t >= 1) {

break;

}

var mid = pt_at_t(curve, t);

2476

if (ptOnScreen(mid))

2477

return drawDirection(curve, t);

2478

}

2479

denom *= 2;

2480

} while (--tries > 0);

2481

drawDirection(curve, defaultT);

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2482

}

2483

2484

function drawID(curve, t, id) {

2485

var px = x_at_t(curve, t);

2486

var py = y_at_t(curve, t);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2487

var _px = (px - srcLeft) * scale;

2488

var _py = (py - srcTop) * scale;

2489

draw_id_at(id, _px, _py);

2490

}

2491

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2492

function localToGlobal(local) {

2493

var global = {};

2494

global.x = (local.x - srcLeft) * scale;

2495

global.y = (local.y - srcTop) * scale;

2496

return global;

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2497

}

2498

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2499

function ptOnScreen(local) {

2500

var pt = localToGlobal(local);

2501

return 10 <= pt.x && pt.x <= screenWidth - 10

2502

&& 10 <= pt.y && pt.y <= screenHeight - 10;

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2503

}

2504

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2505

function drawVisibleID(curve, defaultT, id) {

2506

// determine if either or both ends are visible

2507

var s = pt_at_t(curve, 0);

2508

var e = pt_at_t(curve, 1);

2509

var sOn = ptOnScreen(s);

2510

var eOn = ptOnScreen(e);

2511

if (sOn && eOn)

2512

return drawID(curve, defaultT, id);

2513

if (sOn || eOn) {

2514

var step = sOn ? -defaultT / 2 : (1 - defaultT) / 2;

var t = defaultT;

var tries = 16;

do {

var mid = pt_at_t(curve, t);

2519

if (ptOnScreen(mid))

2520

return drawID(curve, t, id);

2521

t += step;

2522

step /= 2;

2523

} while (--tries > 0);

2524

drawID(curve, defaultT, id);

2525

}

2526

// scattershot until we find a visible point

2527

var denom = 2; // visit odd number num / denom to hit unique pts

2528

var tries = 6; // tries 1/2, 1/4, 3/4, 1/8, 3/8, 5/8, 7/8, 1/16 ...

2529

do {

2530

for (var numer = 1; numer < denom; numer += 2) {

2531

var t = numer / denom;

2532

var mid = pt_at_t(curve, t);

2533

if (ptOnScreen(mid))

2534

return drawID(curve, t, id);

2535

}

2536

denom *= 2;

2537

} while (--tries > 0);

2538

drawID(curve, defaultT, id);

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2539

}

2540

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2541

function draw_id_at(id, _px, _py) {

2542

ctx.beginPath();

2543

ctx.arc(_px, _py, 15, 0, Math.PI * 2, true);

2544

ctx.closePath();

2545

ctx.fillStyle = "white";

2546

ctx.fill();

2547

ctx.strokeStyle = "rgba(127,127,0, 1)";

2548

ctx.fillStyle = "rgba(127,127,0, 1)";

2549

ctx.stroke();

2550

ctx.font = "normal 16px Arial";

2551

ctx.textAlign = "center";

2552

ctx.fillText(id, _px, _py + 5);

2553

ctx.font = "normal 10px Arial";

2554

}

2555

2556

function drawLinePartialID(id, x1, y1, x2, y2, t1, t2) {

2557

var curve = [x1, y1, x2, y2];

2558

drawCurvePartialID(id, curve, t1, t2);

2559

}

2560

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2561

function drawLineID(id, x1, y1, x2, y2) {

2562

drawLinePartialID(id, x1, y1, x2, y2, 0, 1);

2563

}

2564

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2565

function drawQuadPartialID(id, x1, y1, x2, y2, x3, y3, t1, t2) {

2566

var curve = [x1, y1, x2, y2, x3, y3];

2567

drawCurvePartialID(id, curve, t1, t2);

2568

}

2569

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2570

function drawQuadID(id, x1, y1, x2, y2, x3, y3) {

2571

drawQuadPartialID(id, x1, y1, x2, y2, x3, y3, 0, 1);

2572

}

2573

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2574

function drawConicPartialID(id, x1, y1, x2, y2, x3, y3, w, t1, t2) {

2575

var curve = [x1, y1, x2, y2, x3, y3, w];

2576

drawCurvePartialID(id, curve, t1, t2);

2577

}

2578

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2579

function drawConicID(id, x1, y1, x2, y2, x3, y3, w) {

2580

drawConicPartialID(id, x1, y1, x2, y2, x3, y3, w, 0, 1);

2581

}

2582

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2583

function drawCubicPartialID(id, x1, y1, x2, y2, x3, y3, x4, y4, t1, t2) {

2584

var curve = [x1, y1, x2, y2, x3, y3, x4, y4];

2585

drawCurvePartialID(id, curve, t1, t2);

2586

}

2587

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2588

function drawCubicID(id, x1, y1, x2, y2, x3, y3, x4, y4) {

2589

drawCubicPartialID(id, x1, y1, x2, y2, x3, y3, x4, y4, 0, 1);

2590

}

2591

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2592

function drawCurvePartialID(id, curve, t1, t2) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2593

drawVisibleID(curve, (t1 + t2) / 2, id);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2594

}

2595

2596

function drawCurveSpecials(test, curve, type) {

2597

if (pt_labels) {

2598

drawPoints(curve, type, pt_labels == 2);

2599

}

2600

if (control_lines != 0) {

2601

drawControlLines(curve, type, control_lines);

2602

}

2603

if (curve_t) {

2604

drawPointAtT(curve, type);

2605

}

2606

if (draw_midpoint) {

2607

var mid = pointAtT(curve, type, 0.5);

2608

drawPoint(mid.x, mid.y, true);

2609

}

2610

if (draw_id) {

2611

var id = idByCurve(test, curve, type);

2612

if (id >= 0) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2613

drawVisibleID(curve, 0.5, id);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2614

}

2615

}

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2616

if (draw_direction) {

2617

drawVisibleDirection(curve);

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

2618

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2619

if (type == PATH_LINE) {

2620

return;

2621

}

2622

if (draw_deriviatives > 0) {

2623

var d = dxy_at_t(curve, type, 0);

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2624

drawArrow(curve[0], curve[1], d.x, d.y, 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2625

if (draw_deriviatives == 2) {

2626

d = dxy_at_t(curve, type, 1);

2627

if (type == PATH_CUBIC) {

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2628

drawArrow(curve[6], curve[7], d.x, d.y, 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2629

} else {

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2630

drawArrow(curve[4], curve[5], d.x, d.y, 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

}

}

if (draw_midpoint) {

var mid = pointAtT(curve, type, 0.5);

2635

d = dxy_at_t(curve, type, 0.5);

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2636

drawArrow(mid.x, mid.y, d.x, d.y, 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2637

}

2638

}

2639

if (type != PATH_CUBIC) {

2640

return;

2641

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2642

if (draw_sequence) {

2643

var ymin = Math.min(curve[1], curve[3], curve[5], curve[7]);

2644

for (var i = 0; i < 8; i+= 2) {

2645

drawLabelX(ymin, i >> 1, curve[i]);

2646

}

2647

var xmin = Math.min(curve[0], curve[2], curve[4], curve[6]);

2648

for (var i = 1; i < 8; i+= 2) {

2649

drawLabelY(xmin, i >> 1, curve[i]);

}

}

}

function logCurves(test) {

2655

for (curves in test) {

2656

var curve = test[curves];

dumpCurve(curve);

}

}

function curveToString(curve) {

2662

var str = "{{";

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2663

var length = curve.length == 7 ? 6 : curve.length;

2664

if (curve.length == 7) {

2665

str += "{";

2666

}

2667

for (i = 0; i < length; i += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2668

str += curve[i].toFixed(decimal_places) + "," + curve[i + 1].toFixed(decimal_places);

2669

if (i < curve.length - 2) {

2670

str += "}, {";

2671

}

2672

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2673

str += "}";

2674

if (curve.length == 7) {

2675

str += "}, " + curve[6].toFixed(decimal_places);

2676

}

2677

str += "}";

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

return str;

}

function dumpCurve(curve) {

2682

console.log(curveToString(curve));

2683

}

2684

2685

function draw(test, lines, title) {

2686

ctx.fillStyle = "rgba(0,0,0, 0.1)";

2687

ctx.font = "normal 50px Arial";

2688

ctx.textAlign = "left";

2689

ctx.fillText(title, 50, 50);

2690

ctx.font = "normal 10px Arial";

2691

ctx.lineWidth = "1.001"; "0.999";

2692

var secondPath = test.length;

var closeCount = 0;

logStart = -1;

logRange = 0;

// find last active rec type at this step

2697

var curType = test[0];

var curStep = 0;

var hasOp = false;

var lastActive = 0;

var lastAdd = 0;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

2702

var lastCoin = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2703

var lastSect = 0;

2704

var lastSort = 0;

2705

var lastMark = 0;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2706

var lastTop = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

activeCount = 0;

addCount = 0;

angleCount = 0;

opCount = 0;

sectCount = 0;

sortCount = 0;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2713

topCount = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

markCount = 0;

activeMax = 0;

addMax = 0;

angleMax = 0;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

2718

coinMax = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

opMax = 0;

sectMax = 0;

sectMax2 = 0;

sortMax = 0;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2723

topMax = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2724

markMax = 0;

2725

lastIndex = test.length - 3;

2726

for (var tIndex = 0; tIndex < test.length; tIndex += 3) {

2727

var recType = test[tIndex];

2728

if (!typeof recType == 'number' || recType < REC_TYPE_UNKNOWN || recType > REC_TYPE_LAST) {

2729

console.log("unknown rec type: " + recType);

2730

throw "stop execution";

2731

}

2732

// if (curType == recType && curType != REC_TYPE_ADD) {

2733

// continue;

2734

// }

2735

var inStepRange = step_limit == 0 || curStep < step_limit;

2736

curType = recType;

2737

if (recType == REC_TYPE_OP) {

hasOp = true;

continue;

}

if (recType == REC_TYPE_UNKNOWN) {

2742

// these types do not advance step

2743

continue;

2744

}

2745

var bumpStep = false;

2746

var records = test[tIndex + 2];

2747

var fragType = records[0];

2748

if (recType == REC_TYPE_ADD) {

2749

if (records.length != 2) {

2750

console.log("expect only two elements: " + records.length);

2751

throw "stop execution";

2752

}

2753

if (fragType == ADD_MOVETO || fragType == ADD_CLOSE) {

continue;

}

++addMax;

if (!draw_add || !inStepRange) {

continue;

}

lastAdd = tIndex;

++addCount;

bumpStep = true;

}

if (recType == REC_TYPE_PATH && hasOp) {

2765

secondPath = tIndex;

2766

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2767

if (recType == REC_TYPE_PATH2 && hasOp) {

2768

secondPath = tIndex;

2769

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2770

if (recType == REC_TYPE_ACTIVE) {

2771

++activeMax;

2772

if (!draw_active || !inStepRange) {

continue;

}

lastActive = tIndex;

++activeCount;

bumpStep = true;

}

if (recType == REC_TYPE_ACTIVE_OP) {

2780

++opMax;

2781

if (!draw_op || !inStepRange) {

continue;

}

lastOp = tIndex;

++opCount;

bumpStep = true;

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2788

if (recType == REC_TYPE_AFTERPART) {

2789

if (draw_angle != 3 || !inStepRange) {

continue;

}

lastAngle = tIndex;

++angleCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2796

if (recType == REC_TYPE_ANGLE) {

2797

++angleMax;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2798

if (draw_angle == 0 || draw_angle == 3 || !inStepRange) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

continue;

}

lastAngle = tIndex;

++angleCount;

bumpStep = true;

}

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

2805

if (recType == REC_TYPE_COINCIDENCE) {

2806

++coinMax;

2807

if (!draw_coincidence || !inStepRange) {

continue;

}

lastCoin = tIndex;

++coinCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2814

if (recType == REC_TYPE_SECT) {

2815

if (records.length != 2) {

2816

console.log("expect only two elements: " + records.length);

2817

throw "stop execution";

}

++sectMax;

var sectBump = 1;

switch (fragType) {

case INTERSECT_LINE:

case INTERSECT_QUAD_LINE:

2824

case INTERSECT_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2825

case INTERSECT_CONIC_LINE:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2826

case INTERSECT_CONIC_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2827

case INTERSECT_CONIC:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2828

case INTERSECT_SELF_CUBIC:

2829

case INTERSECT_CUBIC_LINE:

2830

case INTERSECT_CUBIC_QUAD:

2831

case INTERSECT_CUBIC:

2832

sectBump = 1;

2833

break;

2834

case INTERSECT_LINE_2:

2835

case INTERSECT_QUAD_LINE_2:

2836

case INTERSECT_QUAD_2:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2837

case INTERSECT_CONIC_LINE_2:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2838

case INTERSECT_CONIC_QUAD_2:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2839

case INTERSECT_CONIC_2:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2840

case INTERSECT_CUBIC_LINE_2:

2841

case INTERSECT_CUBIC_QUAD_2:

2842

case INTERSECT_CUBIC_2:

2843

sectBump = 2;

2844

break;

2845

case INTERSECT_LINE_NO:

2846

case INTERSECT_QUAD_LINE_NO:

2847

case INTERSECT_QUAD_NO:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2848

case INTERSECT_CONIC_LINE_NO:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2849

case INTERSECT_CONIC_QUAD_NO:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2850

case INTERSECT_CONIC_NO:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2851

case INTERSECT_SELF_CUBIC_NO:

2852

case INTERSECT_CUBIC_LINE_NO:

2853

case INTERSECT_CUBIC_QUAD_NO:

2854

case INTERSECT_CUBIC_NO:

2855

sectBump = 0;

2856

break;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

2857

case INTERSECT_CONIC_QUAD_3:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2858

case INTERSECT_CUBIC_LINE_3:

2859

case INTERSECT_CUBIC_QUAD_3:

2860

case INTERSECT_CUBIC_3:

2861

sectBump = 3;

2862

break;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

2863

case INTERSECT_CONIC_QUAD_4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2864

case INTERSECT_CUBIC_QUAD_4:

2865

case INTERSECT_CUBIC_4:

sectBump = 4;

break;

default:

console.log("missing case " + records.length);

2870

throw "stop execution";

2871

}

2872

sectMax2 += sectBump;

2873

if (draw_intersection <= 1 || !inStepRange) {

continue;

}

lastSect = tIndex;

sectCount += sectBump;

2878

bumpStep = true;

2879

}

2880

if (recType == REC_TYPE_SORT) {

2881

++sortMax;

2882

if (!draw_sort || !inStepRange) {

continue;

}

lastSort = tIndex;

++sortCount;

bumpStep = true;

}

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2889

if (recType == REC_TYPE_TOP) {

2890

++topMax;

2891

if (!draw_top || !inStepRange) {

continue;

}

lastTop = tIndex;

++topCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2898

if (recType == REC_TYPE_MARK) {

2899

++markMax;

2900

if (!draw_mark || !inStepRange) {

continue;

}

lastMark = tIndex;

++markCount;

bumpStep = true;

}

if (bumpStep) {

lastIndex = tIndex;

logStart = test[tIndex + 1];

2910

logRange = records.length / 2;

++curStep;

}

}

stepMax = (draw_add ? addMax : 0)

2915

+ (draw_active ? activeMax : 0)

reed

0dc4dd6

2015-03-24 13:55:33 -0700

[diff] [blame]

2916

+ (draw_angle ? angleMax : 0)

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

2917

+ (draw_coincidence ? coinMax : 0)

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2918

+ (draw_op ? opMax : 0)

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2919

+ (draw_sort ? sortMax : 0)

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2920

+ (draw_top ? topMax : 0)

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2921

+ (draw_mark ? markMax : 0)

2922

+ (draw_intersection == 2 ? sectMax : draw_intersection == 3 ? sectMax2 : 0);

2923

if (stepMax == 0) {

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

2924

stepMax = addMax + activeMax + angleMax + coinMax + opMax + sortMax + topMax + markMax;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

}

drawnPts = [];

drawnLines = [];

drawnQuads = [];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2929

drawnConics = [];

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2930

drawnCubics = [];

2931

focusXmin = focusYmin = Infinity;

2932

focusXmax = focusYmax = -Infinity;

2933

var pathIndex = 0;

2934

var opLetter = 'S';

2935

for (var tIndex = lastIndex; tIndex >= 0; tIndex -= 3) {

2936

var recType = test[tIndex];

2937

var records = test[tIndex + 2];

2938

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

2939

var fragType = records[recordIndex];

2940

if (!typeof fragType == 'number' || fragType < 1 || fragType > FRAG_TYPE_LAST) {

2941

console.log("unknown in range frag type: " + fragType);

2942

throw "stop execution";

2943

}

2944

var frags = records[recordIndex + 1];

2945

focus_enabled = false;

2946

switch (recType) {

2947

case REC_TYPE_COMPUTED:

2948

if (draw_computed == 0) {

continue;

}

ctx.lineWidth = 1;

ctx.strokeStyle = pathIndex == 0 ? "black" : "red";

2953

ctx.fillStyle = "blue";

2954

var drawThis = false;

2955

switch (fragType) {

2956

case PATH_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2957

if ((draw_computed & 0x9) == 1 || ((draw_computed & 8) != 0

2958

&& (draw_computed & 7) == pathIndex)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2959

drawQuad(frags[0], frags[1], frags[2], frags[3],

frags[4], frags[5]);

drawThis = true;

}

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2964

case PATH_CONIC:

2965

if ((draw_computed & 0xA) == 2 || ((draw_computed & 8) != 0

2966

&& (draw_computed & 7) == pathIndex)) {

2967

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

2968

frags[4], frags[5], frags[6]);

2969

drawThis = true;

2970

}

2971

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2972

case PATH_CUBIC:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2973

if ((draw_computed & 0xC) == 4 || ((draw_computed & 8) != 0

2974

&& (draw_computed & 7) == pathIndex)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2975

drawCubic(frags[0], frags[1], frags[2], frags[3],

2976

frags[4], frags[5], frags[6], frags[7]);

drawThis = true;

}

++pathIndex;

break;

case COMPUTED_SET_1:

pathIndex = 0;

break;

case COMPUTED_SET_2:

pathIndex = 1;

break;

default:

console.log("unknown REC_TYPE_COMPUTED frag type: " + fragType);

2989

throw "stop execution";

2990

}

2991

if (!drawThis || collect_bounds) {

2992

break;

2993

}

2994

drawCurveSpecials(test, frags, fragType);

2995

break;

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

2996

case REC_TYPE_ALIGNED:

2997

if (draw_path < 4) {

2998

continue;

2999

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3000

case REC_TYPE_PATH:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3001

case REC_TYPE_PATH2:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3002

if (REC_TYPE_ALIGNED != recType && draw_path >= 4) {

3003

continue;

3004

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

if (!draw_path) {

continue;

}

var firstPath = tIndex < secondPath;

3009

if ((draw_path & (firstPath ? 1 : 2)) == 0) {

continue;

}

ctx.lineWidth = 1;

ctx.strokeStyle = firstPath ? "black" : "red";

3014

ctx.fillStyle = "blue";

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3015

var frags2 = [];

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3016

switch (fragType) {

3017

case PATH_LINE:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3018

for (var i = 0; i < 4; ++ i) { frags2[i] = frags[i + 1]; }

3019

drawLine(frags2[0], frags2[1], frags2[2], frags2[3]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3020

break;

3021

case PATH_QUAD:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3022

for (var i = 0; i < 6; ++ i) { frags2[i] = frags[i + 1]; }

3023

drawQuad(frags2[0], frags2[1], frags2[2], frags2[3],

3024

frags2[4], frags2[5]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3025

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3026

case PATH_CONIC:

3027

for (var i = 0; i < 7; ++ i) { frags2[i] = frags[i + 1]; }

3028

drawConicWithQuads(frags2[0], frags2[1], frags2[2], frags2[3],

3029

frags2[4], frags2[5], frags2[6]);

3030

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3031

case PATH_CUBIC:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3032

for (var i = 0; i < 8; ++ i) { frags2[i] = frags[i + 1]; }

3033

drawCubic(frags2[0], frags2[1], frags2[2], frags2[3],

3034

frags2[4], frags2[5], frags2[6], frags2[7]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3035

break;

3036

default:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3037

console.log("unknown " + recType + " frag type: " + fragType);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3038

throw "stop execution";

3039

}

3040

if (collect_bounds) {

3041

break;

3042

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3043

drawCurveSpecials(test, frags2, fragType);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

break;

case REC_TYPE_OP:

switch (fragType) {

case OP_INTERSECT: opLetter = 'I'; break;

3048

case OP_DIFFERENCE: opLetter = 'D'; break;

3049

case OP_UNION: opLetter = 'U'; break;

3050

case OP_XOR: opLetter = 'X'; break;

3051

default:

3052

console.log("unknown REC_TYPE_OP frag type: " + fragType);

3053

throw "stop execution";

3054

}

3055

break;

3056

case REC_TYPE_ACTIVE:

3057

if (!draw_active || (step_limit > 0 && tIndex < lastActive)) {

3058

continue;

3059

}

3060

var x1 = frags[SPAN_X1];

3061

var y1 = frags[SPAN_Y1];

3062

var x2 = frags[SPAN_X2];

3063

var y2 = frags[SPAN_Y2];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3064

var x3, y3, x3, y4, w;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3065

ctx.lineWidth = 3;

3066

ctx.strokeStyle = "rgba(0,0,255, 0.3)";

3067

focus_enabled = true;

3068

switch (fragType) {

3069

case ACTIVE_LINE_SPAN:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3070

drawLine(x1, y1, x2, y2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3071

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3072

drawLineID(frags[0], x1, y1, x2, y2);

3073

}

3074

if (pt_labels) {

3075

var curve = [x1, y1, x2, y2];

3076

ctx.fillStyle = "blue";

3077

drawPoints(curve, PATH_LINE, pt_labels == 2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3078

}

3079

break;

3080

case ACTIVE_QUAD_SPAN:

3081

x3 = frags[SPAN_X3];

3082

y3 = frags[SPAN_Y3];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3083

drawQuad(x1, y1, x2, y2, x3, y3);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3084

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3085

drawQuadID(frags[0], x1, y1, x2, y2, x3, y3);

3086

}

3087

if (pt_labels) {

3088

var curve = [x1, y1, x2, y2, x3, y3];

3089

ctx.fillStyle = "blue";

3090

drawPoints(curve, PATH_QUAD, pt_labels == 2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3091

}

3092

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3093

case ACTIVE_CONIC_SPAN:

3094

x3 = frags[SPAN_X3];

3095

y3 = frags[SPAN_Y3];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3096

w = frags[SPAN_K_W];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3097

drawConicWithQuads(x1, y1, x2, y2, x3, y3, w);

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3098

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3099

drawConicID(frags[0], x1, y1, x2, y2, x3, y3, w);

3100

}

3101

if (pt_labels) {

3102

var curve = [x1, y1, x2, y2, x3, y3, w];

3103

ctx.fillStyle = "blue";

3104

drawPoints(curve, PATH_CONIC, pt_labels == 2);

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3105

}

3106

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3107

case ACTIVE_CUBIC_SPAN:

x3 = frags[SPAN_X3];

y3 = frags[SPAN_Y3];

x4 = frags[SPAN_X4];

y4 = frags[SPAN_Y4];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3112

drawCubic(x1, y1, x2, y2, x3, y3, x4, y4);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3113

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3114

drawCubicID(frags[0], x1, y1, x2, y2, x3, y3, x4, y4);

3115

}

3116

if (pt_labels) {

3117

var curve = [x1, y1, x2, y2, x3, y3, x4, y4];

3118

ctx.fillStyle = "blue";

3119

drawPoints(curve, PATH_CUBIC, pt_labels == 2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

}

break;

default:

console.log("unknown REC_TYPE_ACTIVE frag type: " + fragType);

3124

throw "stop execution";

3125

}

3126

break;

3127

case REC_TYPE_ACTIVE_OP:

3128

if (!draw_op || (step_limit > 0 && tIndex < lastOp)) {

3129

continue;

3130

}

3131

focus_enabled = true;

3132

ctx.lineWidth = 3;

3133

var activeSpan = frags[7] == "1";

3134

ctx.strokeStyle = activeSpan ? "rgba(45,160,0, 0.3)" : "rgba(255,45,0, 0.5)";

3135

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

3136

drawCurve(curve);

3137

if (draw_op > 1) {

3138

drawArc(curve, false, frags[3], frags[4]);

3139

drawArc(curve, true, frags[5], frags[6]);

}

break;

case REC_TYPE_ADD:

if (!draw_add) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = closeCount == 0 ? "rgba(0,0,255, 0.3)"

3148

: closeCount == 1 ? "rgba(0,127,0, 0.3)"

3149

: closeCount == 2 ? "rgba(0,127,127, 0.3)"

3150

: closeCount == 3 ? "rgba(127,127,0, 0.3)"

3151

: "rgba(127,0,127, 0.3)";

3152

focus_enabled = true;

switch (fragType) {

case ADD_MOVETO:

break;

case ADD_LINETO:

if (step_limit == 0 || tIndex >= lastAdd) {

3158

drawLine(frags[0], frags[1], frags[2], frags[3]);

}

break;

case ADD_QUADTO:

if (step_limit == 0 || tIndex >= lastAdd) {

3163

drawQuad(frags[0], frags[1], frags[2], frags[3], frags[4], frags[5]);

3164

}

3165

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3166

case ADD_CONICTO:

3167

if (step_limit == 0 || tIndex >= lastAdd) {

3168

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

3169

frags[4], frags[5], frags[6]);

3170

}

3171

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3172

case ADD_CUBICTO:

3173

if (step_limit == 0 || tIndex >= lastAdd) {

3174

drawCubic(frags[0], frags[1], frags[2], frags[3],

3175

frags[4], frags[5], frags[6], frags[7]);

}

break;

case ADD_CLOSE:

++closeCount;

break;

case ADD_FILL:

break;

default:

console.log("unknown REC_TYPE_ADD frag type: " + fragType);

3185

throw "stop execution";

3186

}

3187

break;

3188

case REC_TYPE_ANGLE:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3189

angleBetween = frags[18] == "T";

3190

afterIndex = 0;

3191

if (draw_angle == 0 || draw_angle == 3 || (step_limit > 0 && tIndex < lastAngle)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3192

continue;

3193

}

3194

focus_enabled = true;

3195

ctx.lineWidth = 3;

3196

ctx.strokeStyle = "rgba(127,45,127, 0.3)";

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3197

var leftCurve = curvePartialByID(test, frags[0], frags[4], frags[5]);

3198

var midCurve = curvePartialByID(test, frags[6], frags[10], frags[11]);

3199

var rightCurve = curvePartialByID(test, frags[12], frags[16], frags[17]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3200

drawCurve(leftCurve);

3201

drawCurve(rightCurve);

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3202

ctx.strokeStyle = angleBetween ? "rgba(0,160,45, 0.3)" : "rgba(255,0,45, 0.5)";

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3203

drawCurve(midCurve);

3204

if (draw_angle > 1) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3205

drawVisibleOrder(leftCurve, 'L');

3206

drawVisibleOrder(rightCurve, 'R');

3207

}

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3208

if (draw_id) {

3209

drawVisibleID(leftCurve, 0.5, frags[0]);

3210

drawVisibleID(midCurve, 0.5, frags[6]);

3211

drawVisibleID(rightCurve, 0.5, frags[12]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3212

}

3213

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3214

case REC_TYPE_AFTERPART:

3215

if (draw_angle != 3 || (step_limit > 0 && tIndex < lastAngle)) {

3216

continue;

3217

}

3218

ctx.strokeStyle = afterIndex == 0 ? "rgba(255,0,0, 1.0)"

3219

: (afterIndex == 1) == angleBetween ? "rgba(0,128,0, 1.0)"

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3220

: "rgba(0,0,255, 1.0)";

3221

var curve;

3222

var id;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3223

switch (fragType) {

3224

case PATH_LINE:

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3225

curve = [ frags[0], frags[1], frags[2], frags[3] ];

3226

id = frags[4];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3227

break;

3228

case PATH_QUAD:

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3229

curve = [ frags[0], frags[1], frags[2], frags[3],

3230

frags[4], frags[5] ];

3231

id = frags[6];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3232

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3233

case PATH_CONIC:

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3234

curve = [ frags[0], frags[1], frags[2], frags[3],

3235

frags[4], frags[5], frags[6] ];

3236

id = frags[7];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3237

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3238

case PATH_CUBIC:

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3239

curve = [ frags[0], frags[1], frags[2], frags[3],

3240

frags[4], frags[5], frags[6], frags[7] ];

3241

id = frags[8];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3242

break;

3243

default:

3244

console.log("unknown REC_TYPE_AFTERPART frag type: " + fragType);

3245

throw "stop execution";

3246

}

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3247

drawCurve(curve);

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3248

if (draw_id) {

3249

drawVisibleID(curve, 0.5, id);

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3250

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3251

++afterIndex;

3252

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3253

case REC_TYPE_COINCIDENCE:

3254

if (!draw_coincidence || (step_limit > 0 && tIndex < lastCoin)) {

3255

continue;

3256

}

3257

focus_enabled = true;

3258

ctx.lineWidth = 3;

3259

ctx.strokeStyle = "rgba(127,45,63, 0.3)";

3260

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

3261

drawCurve(curve);

3262

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3263

case REC_TYPE_SECT:

3264

if (!draw_intersection) {

3265

continue;

3266

}

3267

if (draw_intersection != 1 && (step_limit > 0 && tIndex < lastSect)) {

3268

continue;

3269

}

3270

// draw_intersection == 1 : show all

3271

// draw_intersection == 2 : step == 0 ? show all : show intersection line #step

3272

// draw_intersection == 3 : step == 0 ? show all : show intersection #step

3273

ctx.lineWidth = 1;

3274

ctx.strokeStyle = "rgba(0,0,255, 0.3)";

3275

ctx.fillStyle = "blue";

3276

focus_enabled = true;

var f = [];

var c1s;

var c1l;

var c2s;

var c2l;

switch (fragType) {

case INTERSECT_LINE:

f.push(5, 6, 0, 7);

c1s = 1; c1l = 4; c2s = 8; c2l = 4;

3286

break;

3287

case INTERSECT_LINE_2:

3288

f.push(5, 6, 0, 10);

3289

f.push(8, 9, 7, 15);

3290

c1s = 1; c1l = 4; c2s = 11; c2l = 4;

3291

break;

3292

case INTERSECT_LINE_NO:

3293

c1s = 0; c1l = 4; c2s = 4; c2l = 4;

3294

break;

3295

case INTERSECT_QUAD_LINE:

3296

f.push(7, 8, 0, 9);

3297

c1s = 1; c1l = 6; c2s = 10; c2l = 4;

3298

break;

3299

case INTERSECT_QUAD_LINE_2:

3300

f.push(7, 8, 0, 12);

3301

f.push(10, 11, 9, 17);

3302

c1s = 1; c1l = 6; c2s = 13; c2l = 4;

3303

break;

3304

case INTERSECT_QUAD_LINE_NO:

3305

c1s = 0; c1l = 6; c2s = 6; c2l = 4;

break;

case INTERSECT_QUAD:

f.push(7, 8, 0, 9);

c1s = 1; c1l = 6; c2s = 10; c2l = 6;

3310

break;

3311

case INTERSECT_QUAD_2:

3312

f.push(7, 8, 0, 12);

3313

f.push(10, 11, 9, 19);

3314

c1s = 1; c1l = 6; c2s = 13; c2l = 6;

3315

break;

3316

case INTERSECT_QUAD_NO:

3317

c1s = 0; c1l = 6; c2s = 6; c2l = 6;

3318

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3319

case INTERSECT_CONIC_LINE:

3320

f.push(8, 9, 0, 10);

3321

c1s = 1; c1l = 7; c2s = 11; c2l = 4;

3322

break;

3323

case INTERSECT_CONIC_LINE_2:

3324

f.push(8, 9, 0, 12);

3325

f.push(11, 12, 10, 18);

3326

c1s = 1; c1l = 7; c2s = 14; c2l = 4;

3327

break;

3328

case INTERSECT_CONIC_LINE_NO:

3329

c1s = 0; c1l = 7; c2s = 7; c2l = 4;

3330

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3331

case INTERSECT_CONIC_QUAD:

3332

f.push(8, 9, 0, 10);

3333

c1s = 1; c1l = 7; c2s = 11; c2l = 6;

3334

break;

3335

case INTERSECT_CONIC_QUAD_2:

3336

f.push(8, 9, 0, 12);

3337

f.push(11, 12, 10, 18);

3338

c1s = 1; c1l = 7; c2s = 14; c2l = 6;

3339

break;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

3340

case INTERSECT_CONIC_QUAD_3:

3341

f.push(8, 9, 0, 15);

3342

f.push(11, 12, 10, 21);

3343

f.push(14, 15, 13, 22);

3344

c1s = 1; c1l = 7; c2s = 17; c2l = 6;

3345

break;

3346

case INTERSECT_CONIC_QUAD_4:

3347

f.push(8, 9, 0, 18);

3348

f.push(11, 12, 10, 24);

3349

f.push(14, 15, 13, 25);

3350

f.push(17, 18, 16, 26);

3351

c1s = 1; c1l = 7; c2s = 20; c2l = 6;

3352

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3353

case INTERSECT_CONIC_QUAD_NO:

3354

c1s = 0; c1l = 7; c2s = 7; c2l = 6;

3355

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3356

case INTERSECT_CONIC:

3357

f.push(8, 9, 0, 10);

3358

c1s = 1; c1l = 7; c2s = 11; c2l = 7;

3359

break;

3360

case INTERSECT_CONIC_2:

3361

f.push(8, 9, 0, 13);

3362

f.push(11, 12, 10, 21);

3363

c1s = 1; c1l = 7; c2s = 14; c2l = 7;

3364

break;

3365

case INTERSECT_CONIC_NO:

3366

c1s = 0; c1l = 7; c2s = 7; c2l = 7;

3367

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3368

case INTERSECT_SELF_CUBIC:

3369

f.push(9, 10, 0, 11);

3370

c1s = 1; c1l = 8; c2s = 0; c2l = 0;

3371

break;

3372

case INTERSECT_SELF_CUBIC_NO:

3373

c1s = 0; c1l = 8; c2s = 0; c2l = 0;

3374

break;

3375

case INTERSECT_CUBIC_LINE:

3376

f.push(9, 10, 0, 11);

3377

c1s = 1; c1l = 8; c2s = 12; c2l = 4;

3378

break;

3379

case INTERSECT_CUBIC_LINE_2:

3380

f.push(9, 10, 0, 14);

3381

f.push(12, 13, 11, 19);

3382

c1s = 1; c1l = 8; c2s = 15; c2l = 4;

3383

break;

3384

case INTERSECT_CUBIC_LINE_3:

3385

f.push(9, 10, 0, 17);

3386

f.push(12, 13, 11, 22);

3387

f.push(15, 16, 14, 23);

3388

c1s = 1; c1l = 8; c2s = 18; c2l = 4;

3389

break;

3390

case INTERSECT_CUBIC_QUAD_NO:

3391

c1s = 0; c1l = 8; c2s = 8; c2l = 6;

3392

break;

3393

case INTERSECT_CUBIC_QUAD:

3394

f.push(9, 10, 0, 11);

3395

c1s = 1; c1l = 8; c2s = 12; c2l = 6;

3396

break;

3397

case INTERSECT_CUBIC_QUAD_2:

3398

f.push(9, 10, 0, 14);

3399

f.push(12, 13, 11, 21);

3400

c1s = 1; c1l = 8; c2s = 15; c2l = 6;

3401

break;

3402

case INTERSECT_CUBIC_QUAD_3:

3403

f.push(9, 10, 0, 17);

3404

f.push(12, 13, 11, 24);

3405

f.push(15, 16, 14, 25);

3406

c1s = 1; c1l = 8; c2s = 18; c2l = 6;

3407

break;

3408

case INTERSECT_CUBIC_QUAD_4:

3409

f.push(9, 10, 0, 20);

3410

f.push(12, 13, 11, 27);

3411

f.push(15, 16, 14, 28);

3412

f.push(18, 19, 17, 29);

3413

c1s = 1; c1l = 8; c2s = 21; c2l = 6;

3414

break;

3415

case INTERSECT_CUBIC_LINE_NO:

3416

c1s = 0; c1l = 8; c2s = 8; c2l = 4;

3417

break;

3418

case INTERSECT_CUBIC:

3419

f.push(9, 10, 0, 11);

3420

c1s = 1; c1l = 8; c2s = 12; c2l = 8;

3421

break;

3422

case INTERSECT_CUBIC_2:

3423

f.push(9, 10, 0, 14);

3424

f.push(12, 13, 11, 23);

3425

c1s = 1; c1l = 8; c2s = 15; c2l = 8;

3426

break;

3427

case INTERSECT_CUBIC_3:

3428

f.push(9, 10, 0, 17);

3429

f.push(12, 13, 11, 26);

3430

f.push(15, 16, 14, 27);

3431

c1s = 1; c1l = 8; c2s = 18; c2l = 8;

3432

break;

3433

case INTERSECT_CUBIC_4:

3434

f.push(9, 10, 0, 20);

3435

f.push(12, 13, 11, 29);

3436

f.push(15, 16, 14, 30);

3437

f.push(18, 19, 17, 31);

3438

c1s = 1; c1l = 8; c2s = 21; c2l = 8;

3439

break;

3440

case INTERSECT_CUBIC_NO:

3441

c1s = 0; c1l = 8; c2s = 8; c2l = 8;

3442

break;

3443

default:

3444

console.log("unknown REC_TYPE_SECT frag type: " + fragType);

3445

throw "stop execution";

3446

}

3447

if (draw_intersection != 1) {

3448

var id = -1;

3449

var curve;

3450

switch (c1l) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3451

case 4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3452

drawLine(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3]);

3453

if (draw_id) {

3454

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3]];

3455

id = idByCurve(test, curve, PATH_LINE);

}

break;

case 6:

drawQuad(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3460

frags[c1s + 4], frags[c1s + 5]);

3461

if (draw_id) {

3462

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3463

frags[c1s + 4], frags[c1s + 5]];

3464

id = idByCurve(test, curve, PATH_QUAD);

3465

}

3466

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3467

case 7:

3468

drawConicWithQuads(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3469

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6]);

3470

if (draw_id) {

3471

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3472

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6]];

3473

id = idByCurve(test, curve, PATH_CONIC);

3474

}

3475

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3476

case 8:

3477

drawCubic(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3478

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6], frags[c1s + 7]);

3479

if (draw_id) {

3480

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3481

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6], frags[c1s + 7]];

3482

id = idByCurve(test, curve, PATH_CUBIC);

}

break;

}

if (id >= 0) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3487

drawVisibleID(curve, 0.5, id);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

}

id = -1;

switch (c2l) {

case 0:

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3493

case 4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3494

drawLine(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3]);

3495

if (draw_id) {

3496

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3]];

3497

id = idByCurve(test, curve, PATH_LINE);

}

break;

case 6:

drawQuad(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3502

frags[c2s + 4], frags[c2s + 5]);

3503

if (draw_id) {

3504

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3505

frags[c2s + 4], frags[c2s + 5]];

3506

id = idByCurve(test, curve, PATH_QUAD);

3507

}

3508

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3509

case 7:

3510

drawConicWithQuads(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3511

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6]);

3512

if (draw_id) {

3513

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3514

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6]];

3515

id = idByCurve(test, curve, PATH_CONIC);

3516

}

3517

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3518

case 8:

3519

drawCubic(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3520

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6], frags[c2s + 7]);

3521

if (draw_id) {

3522

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3523

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6], frags[c2s + 7]];

3524

id = idByCurve(test, curve, PATH_CUBIC);

}

break;

}

if (id >= 0) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3529

drawVisibleID(curve, 0.5, id);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3530

}

3531

}

3532

if (collect_bounds) {

3533

break;

3534

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3535

if (draw_intersection != 3 || step_limit == 0 || tIndex >= lastSect) {

3536

for (var idx = 0; idx < f.length; idx += 4) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3537

drawPoint(frags[f[idx]], frags[f[idx + 1]], true);

3538

}

3539

}

3540

if (!draw_intersectT) {

3541

break;

3542

}

3543

ctx.fillStyle = "red";

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3544

if (draw_intersection != 3 || step_limit == 0 || tIndex >= lastSect) {

3545

for (var idx = 0; idx < f.length; idx += 4) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3546

drawTAtPointUp(frags[f[idx]], frags[f[idx + 1]], frags[f[idx + 2]]);

3547

drawTAtPointDown(frags[f[idx]], frags[f[idx + 1]], frags[f[idx + 3]]);

}

}

break;

case REC_TYPE_SORT:

if (!draw_sort || (step_limit > 0 && tIndex < lastSort)) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = "rgba(127,127,0, 0.5)";

3557

focus_enabled = true;

switch (fragType) {

case SORT_UNARY:

case SORT_BINARY:

var curve = curvePartialByID(test, frags[0], frags[6], frags[8]);

drawCurve(curve);

break;

default:

console.log("unknown REC_TYPE_SORT frag type: " + fragType);

3566

throw "stop execution";

3567

}

3568

break;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3569

case REC_TYPE_TOP:

3570

if (!draw_top || (step_limit > 0 && tIndex < lastTop)) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = "rgba(127,127,0, 0.5)";

3575

focus_enabled = true;

3576

{

3577

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

3578

drawCurve(curve);

3579

var type = PATH_LINE + (curve.length / 2 - 2);

3580

var mid = pointAtT(curve, type, 0.5);

3581

var d = dxy_at_t(curve, type, 0.5);

3582

drawArrow(mid.x, mid.y, d.x, d.y, 0.3);

3583

}

3584

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3585

case REC_TYPE_MARK:

3586

if (!draw_mark || (step_limit > 0 && tIndex < lastMark)) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = fragType >= MARK_DONE_LINE ?

3591

"rgba(127,0,127, 0.5)" : "rgba(127,127,0, 0.5)";

3592

focus_enabled = true;

switch (fragType) {

case MARK_LINE:

case MARK_DONE_LINE:

case MARK_UNSORTABLE_LINE:

3597

case MARK_SIMPLE_LINE:

3598

case MARK_SIMPLE_DONE_LINE:

3599

case MARK_DONE_UNARY_LINE:

3600

drawLinePartial(frags[1], frags[2], frags[3], frags[4],

3601

frags[5], frags[9]);

3602

if (draw_id) {

3603

drawLinePartialID(frags[0], frags[1], frags[2], frags[3], frags[4],

frags[5], frags[9]);

}

break;

case MARK_QUAD:

case MARK_DONE_QUAD:

case MARK_UNSORTABLE_QUAD:

3610

case MARK_SIMPLE_QUAD:

3611

case MARK_SIMPLE_DONE_QUAD:

3612

case MARK_DONE_UNARY_QUAD:

3613

drawQuadPartial(frags[1], frags[2], frags[3], frags[4],

3614

frags[5], frags[6], frags[7], frags[11]);

3615

if (draw_id) {

3616

drawQuadPartialID(frags[0], frags[1], frags[2], frags[3], frags[4],

3617

frags[5], frags[6], frags[7], frags[11]);

}

break;

case MARK_CUBIC:

case MARK_DONE_CUBIC:

3622

case MARK_UNSORTABLE_CUBIC:

3623

case MARK_SIMPLE_CUBIC:

3624

case MARK_SIMPLE_DONE_CUBIC:

3625

case MARK_DONE_UNARY_CUBIC:

3626

drawCubicPartial(frags[1], frags[2], frags[3], frags[4],

3627

frags[5], frags[6], frags[7], frags[8], frags[9], frags[13]);

3628

if (draw_id) {

3629

drawCubicPartialID(frags[0], frags[1], frags[2], frags[3], frags[4],

3630

frags[5], frags[6], frags[7], frags[8], frags[9], frags[13]);

3631

}

3632

break;

3633

case MARK_ANGLE_LAST:

3634

// FIXME: ignored for now

3635

break;

3636

default:

3637

console.log("unknown REC_TYPE_MARK frag type: " + fragType);

3638

throw "stop execution";

}

break;

default:

continue;

}

}

switch (recType) {

case REC_TYPE_SORT:

if (!draw_sort || (step_limit > 0 && tIndex < lastSort)) {

3648

break;

3649

}

3650

var angles = []; // use tangent lines to describe arcs

var windFrom = [];

var windTo = [];

var opp = [];

var minXY = Number.MAX_VALUE;

3655

var partial;

3656

focus_enabled = true;

3657

var someUnsortable = false;

3658

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

3659

var fragType = records[recordIndex];

3660

var frags = records[recordIndex + 1];

3661

var unsortable = (fragType == SORT_UNARY && frags[14]) ||

3662

(fragType == SORT_BINARY && frags[16]);

3663

someUnsortable |= unsortable;

switch (fragType) {

case SORT_UNARY:

case SORT_BINARY:

partial = curvePartialByID(test, frags[0], frags[6], frags[8]);

3668

break;

3669

default:

3670

console.log("unknown REC_TYPE_SORT frag type: " + fragType);

3671

throw "stop execution";

3672

}

3673

var dx = boundsWidth(partial);

3674

var dy = boundsHeight(partial);

3675

minXY = Math.min(minXY, dx * dx + dy * dy);

3676

if (collect_bounds) {

3677

continue;

3678

}

3679

angles.push(tangent(partial));

3680

var from = frags[12];

var to = frags[12];

var sgn = frags[10];

if (sgn < 0) {

from -= frags[11];

} else if (sgn > 0) {

3686

to -= frags[11];

3687

}

3688

windFrom.push(from + (unsortable ? "!" : ""));

3689

windTo.push(to + (unsortable ? "!" : ""));

3690

opp.push(fragType == SORT_BINARY);

3691

if (draw_sort == 1) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3692

drawVisibleOrder(partial, frags[12]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3693

} else {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3694

drawVisibleOrder(partial, (recordIndex / 2) + 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3695

}

3696

}

3697

var radius = Math.sqrt(minXY) / 2 * scale;

3698

radius = Math.min(50, radius);

3699

var scaledRadius = radius / scale;

3700

var centerX = partial[0];

3701

var centerY = partial[1];

3702

if (collect_bounds) {

3703

if (focus_enabled) {

3704

focusXmin = Math.min(focusXmin, centerX - scaledRadius);

3705

focusYmin = Math.min(focusYmin, centerY - scaledRadius);

3706

focusXmax = Math.max(focusXmax, centerX + scaledRadius);

3707

focusYmax = Math.max(focusYmax, centerY + scaledRadius);

}

break;

}

break;

default:

break;

}

}

if (collect_bounds) {

3717

return;

3718

}

3719

if (draw_log && logStart >= 0) {

3720

ctx.font = "normal 10px Arial";

3721

ctx.textAlign = "left";

3722

ctx.beginPath();

3723

var top = screenHeight - 20 - (logRange + 2) * 10;

3724

ctx.rect(50, top, screenWidth - 100, (logRange + 2) * 10);

3725

ctx.fillStyle = "white";

3726

ctx.fill();

3727

ctx.fillStyle = "rgba(0,0,0, 0.5)";

3728

if (logStart > 0) {

3729

ctx.fillText(lines[logStart - 1], 50, top + 8);

3730

}

3731

ctx.fillStyle = "black";

3732

for (var idx = 0; idx < logRange; ++idx) {

3733

ctx.fillText(lines[logStart + idx], 50, top + 18 + 10 * idx);

3734

}

3735

ctx.fillStyle = "rgba(0,0,0, 0.5)";

3736

if (logStart + logRange < lines.length) {

3737

ctx.fillText(lines[logStart + logRange], 50, top + 18 + 10 * logRange);

}

}

if (draw_legend) {

var pos = 0;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3742

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3743

// drawBox(pos++, "yellow", "black", opLetter, true, '');

3744

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_intersection > 1 ? sectCount : sectMax2, draw_intersection, intersectionKey);

3745

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_add ? addCount : addMax, draw_add, addKey);

3746

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_active ? activeCount : activeMax, draw_active, activeKey);

3747

drawBox(pos++, "rgba(127,127,0, 0.3)", "black", draw_angle ? angleCount : angleMax, draw_angle, angleKey);

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3748

drawBox(pos++, "rgba(127,127,0, 0.3)", "black", draw_coincidence ? coinCount : coinMax, draw_coincidence, coincidenceKey);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3749

drawBox(pos++, "rgba(127,127,0, 0.3)", "black", draw_op ? opCount : opMax, draw_op, opKey);

3750

drawBox(pos++, "rgba(127,127,0, 0.3)", "black", draw_sort ? sortCount : sortMax, draw_sort, sortKey);

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3751

drawBox(pos++, "rgba(127,127,0, 0.3)", "black", draw_top ? topCount : topMax, draw_top, topKey);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3752

drawBox(pos++, "rgba(127,0,127, 0.3)", "black", draw_mark ? markCount : markMax, draw_mark, markKey);

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3753

drawBox(pos++, "black", "white",

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3754

(new Array('P', 'P1', 'P2', 'P', 'p', 'p1', 'p2'))[draw_path], draw_path != 0, pathKey);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3755

drawBox(pos++, "rgba(0,63,0, 0.7)", "white",

3756

(new Array('Q', 'Q', 'C', 'QC', 'Qc', 'Cq'))[draw_computed],

3757

draw_computed != 0, computedKey);

3758

drawBox(pos++, "green", "black", step_limit, drawSomething, '');

3759

drawBox(pos++, "green", "black", stepMax, drawSomething, '');

3760

drawBox(pos++, "rgba(255,0,0, 0.6)", "black", lastIndex, drawSomething & draw_log, '');

3761

drawBox(pos++, "rgba(255,0,0, 0.6)", "black", test.length - 1, drawSomething & draw_log, '');

if (curve_t) {

drawCurveTControl();

}

ctx.font = "normal 20px Arial";

3766

ctx.fillStyle = "rgba(0,0,0, 0.3)";

3767

ctx.textAlign = "right";

3768

ctx.fillText(scale.toFixed(decimal_places) + 'x' , screenWidth - 10, screenHeight - 5);

3769

}

3770

if (draw_hints) {

3771

ctx.font = "normal 10px Arial";

3772

ctx.fillStyle = "rgba(0,0,0, 0.5)";

3773

ctx.textAlign = "right";

3774

var y = 4;

3775

ctx.fillText("control lines : " + controlLinesKey, ctx.screenWidthwidth - 10, pos * 50 + y++ * 10);

3776

ctx.fillText("curve t : " + curveTKey, screenWidth - 10, pos * 50 + y++ * 10);

3777

ctx.fillText("deriviatives : " + deriviativesKey, screenWidth - 10, pos * 50 + y++ * 10);

3778

ctx.fillText("intersect t : " + intersectTKey, screenWidth - 10, pos * 50 + y++ * 10);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3779

ctx.fillText("log : " + logKey, screenWidth - 10, pos * 50 + y++ * 10);

3780

ctx.fillText("log curve : " + logCurvesKey, screenWidth - 10, pos * 50 + y++ * 10);

3781

ctx.fillText("mid point : " + midpointKey, screenWidth - 10, pos * 50 + y++ * 10);

3782

ctx.fillText("points : " + ptsKey, screenWidth - 10, pos * 50 + y++ * 10);

3783

ctx.fillText("sequence : " + sequenceKey, screenWidth - 10, pos * 50 + y++ * 10);

3784

ctx.fillText("xy : " + xyKey, screenWidth - 10, pos * 50 + y++ * 10);

}

}

function drawBox(y, backC, foreC, str, enable, label) {

3789

ctx.beginPath();

3790

ctx.fillStyle = backC;

3791

ctx.rect(screenWidth - 40, y * 50 + 10, 40, 30);

3792

ctx.fill();

3793

ctx.font = "normal 16px Arial";

3794

ctx.fillStyle = foreC;

3795

ctx.textAlign = "center";

3796

ctx.fillText(str, screenWidth - 20, y * 50 + 32);

3797

if (!enable) {

3798

ctx.fillStyle = "rgba(255,255,255, 0.5)";

ctx.fill();

}

if (label != '') {

ctx.font = "normal 9px Arial";

3803

ctx.fillStyle = "black";

3804

ctx.fillText(label, screenWidth - 47, y * 50 + 40);

}

}

function drawCurveTControl() {

3809

ctx.lineWidth = 2;

3810

ctx.strokeStyle = "rgba(0,0,0, 0.3)";

3811

ctx.beginPath();

3812

ctx.rect(screenWidth - 80, 40, 28, screenHeight - 80);

3813

ctx.stroke();

3814

var ty = 40 + curveT * (screenHeight - 80);

3815

ctx.beginPath();

3816

ctx.moveTo(screenWidth - 80, ty);

3817

ctx.lineTo(screenWidth - 85, ty - 5);

3818

ctx.lineTo(screenWidth - 85, ty + 5);

3819

ctx.lineTo(screenWidth - 80, ty);

3820

ctx.fillStyle = "rgba(0,0,0, 0.6)";

3821

ctx.fill();

3822

var num = curveT.toFixed(decimal_places);

3823

ctx.font = "normal 10px Arial";

3824

ctx.textAlign = "left";

3825

ctx.fillText(num, screenWidth - 78, ty);

3826

}

3827

3828

function ptInTControl() {

3829

var e = window.event;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3830

var tgt = e.target || e.srcElement;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3831

var left = tgt.offsetLeft;

3832

var top = tgt.offsetTop;

3833

var x = (e.clientX - left);

3834

var y = (e.clientY - top);

3835

if (x < screenWidth - 80 || x > screenWidth - 50) {

3836

return false;

3837

}

3838

if (y < 40 || y > screenHeight - 80) {

3839

return false;

3840

}

3841

curveT = (y - 40) / (screenHeight - 120);

3842

if (curveT < 0 || curveT > 1) {

3843

throw "stop execution";

}

return true;

}

function drawTop() {

if (tests[testIndex] == null) {

3850

var str = testDivs[testIndex].textContent;

3851

parse_all(str);

3852

var title = testDivs[testIndex].id.toString();

3853

testTitles[testIndex] = title;

3854

}

3855

init(tests[testIndex]);

redraw();

}

function redraw() {

if (focus_on_selection) {

3861

collect_bounds = true;

3862

draw(tests[testIndex], testLines[testIndex], testTitles[testIndex]);

3863

collect_bounds = false;

3864

if (focusXmin < focusXmax && focusYmin < focusYmax) {

3865

setScale(focusXmin, focusXmax, focusYmin, focusYmax);

}

}

ctx.beginPath();

ctx.fillStyle = "white";

3870

ctx.rect(0, 0, screenWidth, screenHeight);

3871

ctx.fill();

3872

draw(tests[testIndex], testLines[testIndex], testTitles[testIndex]);

3873

}

3874

3875

function dumpCurvePartial(test, id, t0, t1) {

3876

var curve = curveByID(test, id);

3877

var name = ["line", "quad", "cubic"][curve.length / 2 - 2];

3878

console.log("id=" + id + " " + name + "=" + curveToString(curve)

3879

+ " t0=" + t0 + " t1=" + t1

3880

+ " partial=" + curveToString(curvePartialByID(test, id, t0, t1)));

3881

}

3882

3883

function dumpAngleTest(test, id, t0, t1) {

3884

var curve = curveByID(test, id);

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3885

console.log(" { {" + curveToString(curve) + "}, "

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3886

+ curve.length / 2 + ", " + t0 + ", " + t1 + ", {} }, //");

3887

}

3888

3889

function dumpLogToConsole() {

if (logStart < 0) {

return;

}

var test = tests[testIndex];

3894

var recType = REC_TYPE_UNKNOWN;

3895

var records;

3896

for (var index = 0; index < test.length; index += 3) {

3897

var lastLineNo = test[index + 1];

3898

if (lastLineNo >= logStart && lastLineNo < logStart + logRange) {

3899

recType = test[index];

3900

records = test[index + 2];

break;

}

}

if (recType == REC_TYPE_UNKNOWN) {

3905

return;

3906

}

3907

var lines = testLines[testIndex];

3908

for (var idx = 0; idx < logRange; ++idx) {

3909

var line = lines[logStart + idx];

3910

console.log(line);

3911

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

3912

var fragType = records[recordIndex];

3913

var frags = records[recordIndex + 1];

3914

if (recType == REC_TYPE_ANGLE && fragType == ANGLE_AFTER) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3915

dumpCurvePartial(test, frags[0], frags[4], frags[5]);

3916

dumpCurvePartial(test, frags[6], frags[10], frags[11]);

3917

dumpCurvePartial(test, frags[12], frags[16], frags[17]);

3918

console.log("\nstatic IntersectData intersectDataSet[] = { //");

3919

dumpAngleTest(test, frags[0], frags[4], frags[5]);

3920

dumpAngleTest(test, frags[6], frags[10], frags[11]);

3921

dumpAngleTest(test, frags[12], frags[16], frags[17]);

3922

console.log("}; //");

}

}

}

}

var activeKey = 'a';

var pathKey = 'b';

var pathBackKey = 'B';

3931

var centerKey = 'c';

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3932

var coincidenceKey = 'C';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3933

var addKey = 'd';

3934

var deriviativesKey = 'f';

3935

var angleKey = 'g';

3936

var angleBackKey = 'G';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3937

var intersectionKey = 'i';

3938

var intersectionBackKey = 'I';

3939

var sequenceKey = 'j';

3940

var midpointKey = 'k';

3941

var logKey = 'l';

3942

var logToConsoleKey = 'L';

var markKey = 'm';

var sortKey = 'o';

var opKey = 'p';

var opBackKey = 'P';

var computedKey = 'q';

3948

var computedBackKey = 'Q';

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3949

var directionKey = 'r';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3950

var stepKey = 's';

3951

var stepBackKey = 'S';

3952

var intersectTKey = 't';

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3953

var topKey = 'T';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3954

var curveTKey = 'u';

3955

var controlLinesBackKey = 'V';

3956

var controlLinesKey = 'v';

3957

var ptsKey = 'x';

3958

var xyKey = 'y';

3959

var logCurvesKey = 'z';

3960

var focusKey = '`';

3961

var idKey = '.';

3962

var retinaKey = '\\';

3963

3964

function doKeyPress(evt) {

3965

var char = String.fromCharCode(evt.charCode);

3966

var focusWasOn = false;

switch (char) {

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

case '8':

case '9':

decimal_places = char - '0';

redraw();

break;

case activeKey:

draw_active ^= true;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3983

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3984

break;

3985

case addKey:

3986

draw_add ^= true;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3987

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3988

break;

3989

case angleKey:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3990

draw_angle = (draw_angle + 1) % 4;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

redraw();

break;

case angleBackKey:

draw_angle = (draw_angle + 2) % 3;

redraw();

break;

case centerKey:

setScale(xmin, xmax, ymin, ymax);

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3999

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4000

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

4001

case coincidenceKey:

4002

draw_coincidence ^= true;

4003

redraw();

4004

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4005

case controlLinesBackKey:

4006

control_lines = (control_lines + 3) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4007

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4008

break;

4009

case controlLinesKey:

4010

control_lines = (control_lines + 1) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4011

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4012

break;

4013

case computedBackKey:

4014

draw_computed = (draw_computed + 5) % 6;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4015

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4016

break;

4017

case computedKey:

4018

draw_computed = (draw_computed + 1) % 6;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4019

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

break;

case curveTKey:

curve_t ^= true;

if (curve_t) {

draw_legend = true;

}

redraw();

break;

case deriviativesKey:

4029

draw_deriviatives = (draw_deriviatives + 1) % 3;

4030

redraw();

4031

break;

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4032

case directionKey:

4033

draw_direction ^= true;

4034

redraw();

4035

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4036

case focusKey:

4037

focus_on_selection ^= true;

4038

setScale(xmin, xmax, ymin, ymax);

4039

redraw();

4040

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

case idKey:

draw_id ^= true;

redraw();

break;

case intersectionBackKey:

4046

draw_intersection = (draw_intersection + 3) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4047

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4048

break;

4049

case intersectionKey:

4050

draw_intersection = (draw_intersection + 1) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4051

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4052

break;

4053

case intersectTKey:

4054

draw_intersectT ^= true;

redraw();

break;

case logCurvesKey:

logCurves(tests[testIndex]);

break;

case logKey:

draw_log ^= true;

redraw();

break;

case logToConsoleKey:

if (draw_log) {

dumpLogToConsole();

}

break;

case markKey:

draw_mark ^= true;

redraw();

break;

case midpointKey:

draw_midpoint ^= true;

redraw();

break;

case opKey:

draw_op = (draw_op + 1) % 3;

redraw();

break;

case opBackKey:

draw_op = (draw_op + 2) % 3;

4083

redraw();

4084

break;

4085

case pathKey:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

4086

draw_path = (draw_path + 1) % (4 + (hasAlignedPath ? 3 : 0));

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4087

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4088

break;

4089

case pathBackKey:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

4090

draw_path = (draw_path + 3 + (hasAlignedPath ? 3 : 0)) % (4 + (hasAlignedPath ? 3 : 0));

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4091

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4092

break;

4093

case ptsKey:

4094

pt_labels = (pt_labels + 1) % 3;

redraw();

break;

case retinaKey:

retina_scale ^= true;

drawTop();

break;

case sequenceKey:

draw_sequence ^= true;

redraw();

break;

case sortKey:

draw_sort = (draw_sort + 1) % 3;

drawTop();

break;

case stepKey:

step_limit++;

if (step_limit > stepMax) {

4112

step_limit = stepMax;

}

redraw();

break;

case stepBackKey:

step_limit--;

if (step_limit < 0) {

step_limit = 0;

}

redraw();

break;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

case topKey:

draw_top ^= true;

redraw();

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4127

case xyKey:

4128

debug_xy = (debug_xy + 1) % 3;

redraw();

break;

case '-':

focusWasOn = focus_on_selection;

4133

if (focusWasOn) {

4134

focus_on_selection = false;

scale /= 1.2;

} else {

scale /= 2;

calcLeftTop();

}

redraw();

focus_on_selection = focusWasOn;

break;

case '=':

case '+':

focusWasOn = focus_on_selection;

4146

if (focusWasOn) {

4147

focus_on_selection = false;

scale *= 1.2;

} else {

scale *= 2;

calcLeftTop();

}

redraw();

focus_on_selection = focusWasOn;

break;

case '?':

draw_hints ^= true;

if (draw_hints && !draw_legend) {

draw_legend = true;

}

redraw();

break;

case '/':

draw_legend ^= true;

redraw();

break;

}

}

function doKeyDown(evt) {

4171

var char = evt.keyCode;

4172

var preventDefault = false;

4173

switch (char) {

4174

case 37: // left arrow

if (evt.shiftKey) {

testIndex -= 9;

}

if (--testIndex < 0)

testIndex = tests.length - 1;

4180

drawTop();

4181

preventDefault = true;

4182

break;

4183

case 39: // right arrow

if (evt.shiftKey) {

testIndex += 9;

}

if (++testIndex >= tests.length)

4188

testIndex = 0;

4189

drawTop();

4190

preventDefault = true;

4191

break;

4192

}

4193

if (preventDefault) {

4194

evt.preventDefault();

return false;

}

return true;

}

(function() {

var hidden = "hidden";

4202

4203

// Standards:

4204

if (hidden in document)

4205

document.addEventListener("visibilitychange", onchange);

4206

else if ((hidden = "mozHidden") in document)

4207

document.addEventListener("mozvisibilitychange", onchange);

4208

else if ((hidden = "webkitHidden") in document)

4209

document.addEventListener("webkitvisibilitychange", onchange);

4210

else if ((hidden = "msHidden") in document)

4211

document.addEventListener("msvisibilitychange", onchange);

4212

// IE 9 and lower:

4213

else if ('onfocusin' in document)

4214

document.onfocusin = document.onfocusout = onchange;

4215

// All others:

4216

else

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4217

window.onpageshow = window.onpagehide

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4218

= window.onfocus = window.onblur = onchange;

4219

4220

function onchange (evt) {

4221

var v = 'visible', h = 'hidden',

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4222

evtMap = {

4223

focus:v, focusin:v, pageshow:v, blur:h, focusout:h, pagehide:h

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4224

};

4225

4226

evt = evt || window.event;

4227

if (evt.type in evtMap)

4228

document.body.className = evtMap[evt.type];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4229

else

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4230

document.body.className = this[hidden] ? "hidden" : "visible";

}

})();

function calcXY() {

var e = window.event;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4236

var tgt = e.target || e.srcElement;

caryclark