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

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

[diff] [blame]

</div>

caryclark

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

[diff] [blame]

328

var testDivs = [

Cary Clark

ea2a632

2018-08-27 13:19:09 -0400

[diff] [blame]

329

bug8228,

caryclark

30b9fdd

2016-08-31 14:36:29 -0700

[diff] [blame]

330

];

caryclark

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

[diff] [blame]

331

332

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;

341

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]

346

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;

351

var control_lines = 0;

352

var curve_t = false;

353

var debug_xy = 1;

354

var focus_enabled = false;

355

var focus_on_selection = false;

356

var step_limit = 0;

357

var draw_active = false;

358

var draw_add = false;

359

var draw_angle = 0;

caryclark

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

[diff] [blame]

360

var draw_coincidence = false;

caryclark

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

[diff] [blame]

361

var draw_deriviatives = 0;

Cary Clark

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

[diff] [blame]

362

var draw_direction = false;

caryclark

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

[diff] [blame]

363

var draw_hints = false;

caryclark

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

[diff] [blame]

364

var draw_id = false;

365

var draw_intersection = 0;

366

var draw_intersectT = false;

367

var draw_legend = true;

368

var draw_log = false;

369

var draw_mark = false;

370

var draw_midpoint = false;

371

var draw_op = 0;

372

var draw_sequence = false;

373

var draw_sort = 0;

caryclark

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

[diff] [blame]

374

var draw_top = false;

caryclark

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

[diff] [blame]

375

var draw_path = 3;

376

var draw_computed = 0;

377

var retina_scale = !!window.devicePixelRatio;

var activeCount = 0;

var addCount = 0;

var angleCount = 0;

caryclark

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

[diff] [blame]

382

var coinCount = 0;

caryclark

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

[diff] [blame]

383

var opCount = 0;

384

var sectCount = 0;

385

var sortCount = 0;

caryclark

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

[diff] [blame]

386

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]

391

var coinMax = 0;

caryclark

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

[diff] [blame]

392

var sectMax = 0;

393

var sectMax2 = 0;

394

var sortMax = 0;

caryclark

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

[diff] [blame]

395

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]

401

var hasAlignedPath = false;

caryclark

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

[diff] [blame]

402

var hasComputedPath = false;

caryclark

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

[diff] [blame]

403

var angleBetween = false;

404

var afterIndex = 0;

caryclark

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

[diff] [blame]

405

406

var firstActiveSpan = -1;

var logStart = -1;

var logRange = 0;

var SPAN_ID = 0;

var SPAN_X1 = SPAN_ID + 1;

412

var SPAN_Y1 = SPAN_X1 + 1;

413

var SPAN_X2 = SPAN_Y1 + 1;

414

var SPAN_Y2 = SPAN_X2 + 1;

caryclark

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

[diff] [blame]

415

caryclark

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

[diff] [blame]

416

var SPAN_L_TX = SPAN_Y2 + 1;

caryclark

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

[diff] [blame]

417

var SPAN_L_TY = SPAN_L_TX + 1;

caryclark

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

[diff] [blame]

418

var SPAN_L_OTHER = SPAN_L_TY + 1;

caryclark

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

[diff] [blame]

419

var SPAN_L_OTHERT = SPAN_L_OTHER + 1;

420

var SPAN_L_OTHERI = SPAN_L_OTHERT + 1;

421

var SPAN_L_SUM = SPAN_L_OTHERI + 1;

422

var SPAN_L_VAL = SPAN_L_SUM + 1;

423

var SPAN_L_OPP = SPAN_L_VAL + 1;

424

425

var SPAN_X3 = SPAN_Y2 + 1;

426

var SPAN_Y3 = SPAN_X3 + 1;

caryclark

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

[diff] [blame]

427

caryclark

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

[diff] [blame]

428

var SPAN_Q_TX = SPAN_Y3 + 1;

caryclark

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

[diff] [blame]

429

var SPAN_Q_TY = SPAN_Q_TX + 1;

caryclark

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

[diff] [blame]

430

var SPAN_Q_OTHER = SPAN_Q_TY + 1;

caryclark

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

[diff] [blame]

431

var SPAN_Q_OTHERT = SPAN_Q_OTHER + 1;

432

var SPAN_Q_OTHERI = SPAN_Q_OTHERT + 1;

433

var SPAN_Q_SUM = SPAN_Q_OTHERI + 1;

434

var SPAN_Q_VAL = SPAN_Q_SUM + 1;

435

var SPAN_Q_OPP = SPAN_Q_VAL + 1;

436

caryclark

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

[diff] [blame]

437

var SPAN_K_W = SPAN_Y3 + 1;

caryclark

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

[diff] [blame]

438

var SPAN_K_TX = SPAN_K_W + 1;

caryclark

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

[diff] [blame]

439

var SPAN_K_TY = SPAN_K_TX + 1;

caryclark

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

[diff] [blame]

440

var SPAN_K_OTHER = SPAN_K_TY + 1;

caryclark

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

[diff] [blame]

441

var SPAN_K_OTHERT = SPAN_K_OTHER + 1;

442

var SPAN_K_OTHERI = SPAN_K_OTHERT + 1;

443

var SPAN_K_SUM = SPAN_K_OTHERI + 1;

444

var SPAN_K_VAL = SPAN_K_SUM + 1;

445

var SPAN_K_OPP = SPAN_K_VAL + 1;

446

caryclark

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

[diff] [blame]

447

var SPAN_X4 = SPAN_Y3 + 1;

448

var SPAN_Y4 = SPAN_X4 + 1;

caryclark

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

[diff] [blame]

449

caryclark

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

[diff] [blame]

450

var SPAN_C_TX = SPAN_Y4 + 1;

caryclark

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

[diff] [blame]

451

var SPAN_C_TY = SPAN_C_TX + 1;

caryclark

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

[diff] [blame]

452

var SPAN_C_OTHER = SPAN_C_TY + 1;

caryclark

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

[diff] [blame]

453

var SPAN_C_OTHERT = SPAN_C_OTHER + 1;

454

var SPAN_C_OTHERI = SPAN_C_OTHERT + 1;

455

var SPAN_C_SUM = SPAN_C_OTHERI + 1;

456

var SPAN_C_VAL = SPAN_C_SUM + 1;

457

var SPAN_C_OPP = SPAN_C_VAL + 1;

458

459

var ACTIVE_LINE_SPAN = 1;

460

var ACTIVE_QUAD_SPAN = ACTIVE_LINE_SPAN + 1;

caryclark

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

[diff] [blame]

461

var ACTIVE_CONIC_SPAN = ACTIVE_QUAD_SPAN + 1;

462

var ACTIVE_CUBIC_SPAN = ACTIVE_CONIC_SPAN + 1;

caryclark

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

[diff] [blame]

463

464

var ADD_MOVETO = ACTIVE_CUBIC_SPAN + 1;

465

var ADD_LINETO = ADD_MOVETO + 1;

466

var ADD_QUADTO = ADD_LINETO + 1;

caryclark

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

[diff] [blame]

467

var ADD_CONICTO = ADD_QUADTO + 1;

468

var ADD_CUBICTO = ADD_CONICTO + 1;

caryclark

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

[diff] [blame]

469

var ADD_CLOSE = ADD_CUBICTO + 1;

470

var ADD_FILL = ADD_CLOSE + 1;

471

472

var PATH_LINE = ADD_FILL + 1;

473

var PATH_QUAD = PATH_LINE + 1;

caryclark

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

[diff] [blame]

474

var PATH_CONIC = PATH_QUAD + 1;

475

var PATH_CUBIC = PATH_CONIC + 1;

caryclark

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

[diff] [blame]

476

477

var INTERSECT_LINE = PATH_CUBIC + 1;

478

var INTERSECT_LINE_2 = INTERSECT_LINE + 1;

479

var INTERSECT_LINE_NO = INTERSECT_LINE_2 + 1;

480

var INTERSECT_QUAD_LINE = INTERSECT_LINE_NO + 1;

481

var INTERSECT_QUAD_LINE_2 = INTERSECT_QUAD_LINE + 1;

482

var INTERSECT_QUAD_LINE_NO = INTERSECT_QUAD_LINE_2 + 1;

483

var INTERSECT_QUAD = INTERSECT_QUAD_LINE_NO + 1;

484

var INTERSECT_QUAD_2 = INTERSECT_QUAD + 1;

485

var INTERSECT_QUAD_NO = INTERSECT_QUAD_2 + 1;

caryclark

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

[diff] [blame]

486

var INTERSECT_CONIC_LINE = INTERSECT_QUAD_NO + 1;

487

var INTERSECT_CONIC_LINE_2 = INTERSECT_CONIC_LINE + 1;

488

var INTERSECT_CONIC_LINE_NO = INTERSECT_CONIC_LINE_2 + 1;

caryclark

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

[diff] [blame]

489

var INTERSECT_CONIC_QUAD = INTERSECT_CONIC_LINE_NO + 1;

490

var INTERSECT_CONIC_QUAD_2 = INTERSECT_CONIC_QUAD + 1;

caryclark

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

[diff] [blame]

491

var INTERSECT_CONIC_QUAD_3 = INTERSECT_CONIC_QUAD_2 + 1;

492

var INTERSECT_CONIC_QUAD_4 = INTERSECT_CONIC_QUAD_3 + 1;

493

var INTERSECT_CONIC_QUAD_NO = INTERSECT_CONIC_QUAD_4 + 1;

caryclark

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

[diff] [blame]

494

var INTERSECT_CONIC = INTERSECT_CONIC_QUAD_NO + 1;

caryclark

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

[diff] [blame]

495

var INTERSECT_CONIC_2 = INTERSECT_CONIC + 1;

496

var INTERSECT_CONIC_NO = INTERSECT_CONIC_2 + 1;

497

var INTERSECT_SELF_CUBIC = INTERSECT_CONIC_NO + 1;

caryclark

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

[diff] [blame]

498

var INTERSECT_SELF_CUBIC_NO = INTERSECT_SELF_CUBIC + 1;

499

var INTERSECT_CUBIC_LINE = INTERSECT_SELF_CUBIC_NO + 1;

500

var INTERSECT_CUBIC_LINE_2 = INTERSECT_CUBIC_LINE + 1;

501

var INTERSECT_CUBIC_LINE_3 = INTERSECT_CUBIC_LINE_2 + 1;

502

var INTERSECT_CUBIC_LINE_NO = INTERSECT_CUBIC_LINE_3 + 1;

503

var INTERSECT_CUBIC_QUAD = INTERSECT_CUBIC_LINE_NO + 1;

504

var INTERSECT_CUBIC_QUAD_2 = INTERSECT_CUBIC_QUAD + 1;

505

var INTERSECT_CUBIC_QUAD_3 = INTERSECT_CUBIC_QUAD_2 + 1;

506

var INTERSECT_CUBIC_QUAD_4 = INTERSECT_CUBIC_QUAD_3 + 1;

507

var INTERSECT_CUBIC_QUAD_NO = INTERSECT_CUBIC_QUAD_4 + 1;

508

var INTERSECT_CUBIC = INTERSECT_CUBIC_QUAD_NO + 1;

509

var INTERSECT_CUBIC_2 = INTERSECT_CUBIC + 1;

510

var INTERSECT_CUBIC_3 = INTERSECT_CUBIC_2 + 1;

511

var INTERSECT_CUBIC_4 = INTERSECT_CUBIC_3 + 1;

512

// FIXME: add cubic 5- 9

513

var INTERSECT_CUBIC_NO = INTERSECT_CUBIC_4 + 1;

514

515

var SORT_UNARY = INTERSECT_CUBIC_NO + 1;

516

var SORT_BINARY = SORT_UNARY + 1;

517

518

var OP_DIFFERENCE = SORT_BINARY + 1;

519

var OP_INTERSECT = OP_DIFFERENCE + 1;

520

var OP_UNION = OP_INTERSECT + 1;

521

var OP_XOR = OP_UNION + 1;

522

523

var MARK_LINE = OP_XOR + 1;

524

var MARK_QUAD = MARK_LINE + 1;

caryclark

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

[diff] [blame]

525

var MARK_CONIC = MARK_QUAD + 1;

526

var MARK_CUBIC = MARK_CONIC + 1;

caryclark

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

[diff] [blame]

527

var MARK_DONE_LINE = MARK_CUBIC + 1;

528

var MARK_DONE_QUAD = MARK_DONE_LINE + 1;

caryclark

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

[diff] [blame]

529

var MARK_DONE_CONIC = MARK_DONE_QUAD + 1;

530

var MARK_DONE_CUBIC = MARK_DONE_CONIC + 1;

caryclark

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

[diff] [blame]

531

var MARK_UNSORTABLE_LINE = MARK_DONE_CUBIC + 1;

532

var MARK_UNSORTABLE_QUAD = MARK_UNSORTABLE_LINE + 1;

caryclark

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

[diff] [blame]

533

var MARK_UNSORTABLE_CONIC = MARK_UNSORTABLE_QUAD + 1;

534

var MARK_UNSORTABLE_CUBIC = MARK_UNSORTABLE_CONIC + 1;

caryclark

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

[diff] [blame]

535

var MARK_SIMPLE_LINE = MARK_UNSORTABLE_CUBIC + 1;

536

var MARK_SIMPLE_QUAD = MARK_SIMPLE_LINE + 1;

caryclark

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

[diff] [blame]

537

var MARK_SIMPLE_CONIC = MARK_SIMPLE_QUAD + 1;

538

var MARK_SIMPLE_CUBIC = MARK_SIMPLE_CONIC + 1;

caryclark

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

[diff] [blame]

539

var MARK_SIMPLE_DONE_LINE = MARK_SIMPLE_CUBIC + 1;

540

var MARK_SIMPLE_DONE_QUAD = MARK_SIMPLE_DONE_LINE + 1;

caryclark

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

[diff] [blame]

541

var MARK_SIMPLE_DONE_CONIC = MARK_SIMPLE_DONE_QUAD + 1;

542

var MARK_SIMPLE_DONE_CUBIC = MARK_SIMPLE_DONE_CONIC + 1;

caryclark

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

[diff] [blame]

543

var MARK_DONE_UNARY_LINE = MARK_SIMPLE_DONE_CUBIC + 1;

544

var MARK_DONE_UNARY_QUAD = MARK_DONE_UNARY_LINE + 1;

caryclark

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

[diff] [blame]

545

var MARK_DONE_UNARY_CONIC = MARK_DONE_UNARY_QUAD + 1;

546

var MARK_DONE_UNARY_CUBIC = MARK_DONE_UNARY_CONIC + 1;

caryclark

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

[diff] [blame]

547

var MARK_ANGLE_LAST = MARK_DONE_UNARY_CUBIC + 1;

548

549

var COMPUTED_SET_1 = MARK_ANGLE_LAST + 1;

550

var COMPUTED_SET_2 = COMPUTED_SET_1 + 1;

551

caryclark

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

[diff] [blame]

552

var ANGLE_AFTER = COMPUTED_SET_2 + 1;

caryclark

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

[diff] [blame]

553

var ANGLE_AFTERPART = ANGLE_AFTER + 1;

caryclark

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

[diff] [blame]

554

caryclark

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

[diff] [blame]

555

var ACTIVE_OP = ANGLE_AFTERPART + 1;

caryclark

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

[diff] [blame]

556

caryclark

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

[diff] [blame]

557

var COIN_MAIN_SPAN = ACTIVE_OP + 1;

558

var COIN_OPP_SPAN = COIN_MAIN_SPAN + 1;

559

560

var FRAG_TYPE_LAST = COIN_OPP_SPAN;

caryclark

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

[diff] [blame]

561

562

var REC_TYPE_UNKNOWN = -1;

563

var REC_TYPE_PATH = 0;

caryclark

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

[diff] [blame]

564

var REC_TYPE_PATH2 = 1;

565

var REC_TYPE_SECT = 2;

566

var REC_TYPE_ACTIVE = 3;

567

var REC_TYPE_ADD = 4;

568

var REC_TYPE_SORT = 5;

569

var REC_TYPE_OP = 6;

570

var REC_TYPE_MARK = 7;

571

var REC_TYPE_COMPUTED = 8;

572

var REC_TYPE_COIN = 9;

573

var REC_TYPE_ANGLE = 10;

574

var REC_TYPE_ACTIVE_OP = 11;

575

var REC_TYPE_AFTERPART = 12;

caryclark

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

[diff] [blame]

576

var REC_TYPE_TOP = 13;

caryclark

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

[diff] [blame]

577

var REC_TYPE_COINCIDENCE = 14;

caryclark

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

[diff] [blame]

578

var REC_TYPE_ALIGNED = 15;

579

var REC_TYPE_LAST = REC_TYPE_ALIGNED;

caryclark

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

[diff] [blame]

580

581

function strs_to_nums(strs) {

582

var result = [];

583

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

584

var str = strs[idx];

585

var num = parseFloat(str);

if (isNaN(num)) {

result.push(str);

} else {

result.push(num);

}

}

return result;

}

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

596

if (regex.test(str)) {

597

var strs = regex.exec(str);

598

var result = strs_to_nums(strs);

array.push(id);

array.push(result);

return true;

}

return false;

}

function construct_regexp2(pattern) {

607

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

608

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

609

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

caryclark

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

[diff] [blame]

610

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

caryclark

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

[diff] [blame]

611

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

612

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

613

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

caryclark

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

[diff] [blame]

614

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

caryclark

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

[diff] [blame]

615

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

616

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

617

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

caryclark

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

[diff] [blame]

618

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

caryclark

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

[diff] [blame]

619

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

caryclark

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

[diff] [blame]

620

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

caryclark

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

[diff] [blame]

621

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

622

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

623

return new RegExp(escape, 'i');

624

}

625

626

function construct_regexp2c(pattern) {

627

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

628

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

caryclark

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

[diff] [blame]

629

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]

630

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]

631

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

632

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

caryclark

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

[diff] [blame]

633

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

caryclark

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

[diff] [blame]

634

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

caryclark

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

[diff] [blame]

635

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

caryclark

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

[diff] [blame]

636

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]

637

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

caryclark

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

[diff] [blame]

638

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

caryclark

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

[diff] [blame]

639

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

640

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

641

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

caryclark

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

[diff] [blame]

642

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

caryclark

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

[diff] [blame]

643

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

644

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

645

return new RegExp(escape, 'i');

646

}

647

648

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

649

var regex = construct_regexp2(pattern);

650

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

651

return true;

652

}

653

regex = construct_regexp2c(pattern);

654

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

655

}

656

657

function endsWith(str, suffix) {

658

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

659

}

660

661

function parse_all(test) {

662

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

663

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

664

var record = [];

665

var recType = REC_TYPE_UNKNOWN;

666

var lastLineNo;

667

var moveX, moveY;

668

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

669

var line = lines[lineNo];

670

if (line.length == 0) {

671

continue;

672

}

673

var opStart = "SkOpSegment::";

674

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

675

line = line.substr(opStart.length);

676

}

677

var angleStart = "SkOpAngle::";

678

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

679

line = line.substr(angleStart.length);

680

}

caryclark

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

[diff] [blame]

681

var coinStart = "SkOpCoincidence::";

682

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

683

line = line.substr(coinStart.length);

684

}

caryclark

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

[diff] [blame]

685

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

caryclark

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

[diff] [blame]

686

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

caryclark

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

[diff] [blame]

687

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

caryclark

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

[diff] [blame]

688

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

caryclark

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

[diff] [blame]

689

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

caryclark

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

[diff] [blame]

690

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

691

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

692

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

693

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

caryclark

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

[diff] [blame]

694

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

caryclark

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

[diff] [blame]

695

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

caryclark

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

[diff] [blame]

696

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

caryclark

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

[diff] [blame]

697

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

698

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

Cary Clark

59d5a0e

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

[diff] [blame]

699

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

caryclark

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

[diff] [blame]

700

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

701

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

caryclark

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

[diff] [blame]

702

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

caryclark

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

[diff] [blame]

703

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

704

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

705

: REC_TYPE_UNKNOWN;

706

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

707

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

708

if (recType != REC_TYPE_UNKNOWN) {

709

records.push(recType);

710

records.push(lastLineNo);

711

records.push(record);

}

record = [];

recType = type;

lastLineNo = lineNo;

}

var found = false;

switch (recType) {

case REC_TYPE_ACTIVE:

720

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

caryclark

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

[diff] [blame]

721

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

caryclark

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

[diff] [blame]

722

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

caryclark

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

[diff] [blame]

723

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

caryclark

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

[diff] [blame]

724

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

caryclark

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

[diff] [blame]

725

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

caryclark

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

[diff] [blame]

726

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

caryclark

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

[diff] [blame]

727

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

caryclark

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

[diff] [blame]

728

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

caryclark

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

[diff] [blame]

729

" 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]

730

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

caryclark

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

[diff] [blame]

731

" 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]

732

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

caryclark

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

[diff] [blame]

733

" 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]

734

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

caryclark

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

[diff] [blame]

735

" 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]

736

);

737

break;

738

case REC_TYPE_ACTIVE_OP:

739

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

740

" 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);")) {

745

moveX = record[1][0];

746

moveY = record[1][1];

747

found = true;

748

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

749

record[1].unshift(moveY);

750

record[1].unshift(moveX);

751

moveX = record[1][2];

752

moveY = record[1][3];

753

found = true;

754

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

755

record[1].unshift(moveY);

756

record[1].unshift(moveX);

757

moveX = record[1][4];

758

moveY = record[1][5];

759

found = true;

caryclark

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

[diff] [blame]

760

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

761

record[1].unshift(moveY);

762

record[1].unshift(moveX);

763

moveX = record[1][4];

764

moveY = record[1][5];

765

found = true;

caryclark

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

[diff] [blame]

766

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

767

record[1].unshift(moveY);

768

record[1].unshift(moveX);

769

moveX = record[1][6];

770

moveY = record[1][7];

771

found = true;

772

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

773

found = true;

774

} else {

775

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

776

}

777

break;

caryclark

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

[diff] [blame]

778

case REC_TYPE_AFTERPART:

Cary Clark

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

[diff] [blame]

779

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

780

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

781

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

782

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

caryclark

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

[diff] [blame]

783

break;

caryclark

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

[diff] [blame]

784

case REC_TYPE_ALIGNED:

785

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

786

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

787

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

788

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

789

);

790

break;

caryclark

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

[diff] [blame]

791

case REC_TYPE_ANGLE:

Cary Clark

59d5a0e

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

[diff] [blame]

792

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

caryclark

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

[diff] [blame]

793

"[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]

798

case REC_TYPE_COINCIDENCE:

799

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

800

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

801

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

802

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

803

);

804

break;

caryclark

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

[diff] [blame]

805

case REC_TYPE_COMPUTED:

806

found = line == "computed quadratics given"

807

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

808

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

809

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

caryclark

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

[diff] [blame]

810

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

caryclark

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

[diff] [blame]

811

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

812

);

813

break;

814

case REC_TYPE_PATH:

caryclark

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

[diff] [blame]

815

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

816

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

caryclark

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

[diff] [blame]

817

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

caryclark

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

[diff] [blame]

818

) || 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}"

823

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

caryclark

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

[diff] [blame]

824

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

caryclark

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

[diff] [blame]

825

) || 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" +

830

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

831

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

832

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

833

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

834

" no intersect LINE_VAL LINE_VAL"

835

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

836

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

837

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

838

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

839

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

840

" no intersect QUAD_VAL LINE_VAL"

841

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

842

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

843

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

844

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

845

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

846

" no intersect QUAD_VAL QUAD_VAL"

caryclark

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

[diff] [blame]

847

caryclark

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

[diff] [blame]

848

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

849

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

850

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

851

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

852

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

853

" no intersect CONIC_VAL LINE_VAL"

caryclark

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

[diff] [blame]

854

855

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

856

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

857

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

858

" 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]

859

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

860

" 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"

861

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

862

" 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]

863

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

864

" no intersect CONIC_VAL QUAD_VAL"

865

caryclark

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

[diff] [blame]

866

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

867

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

868

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

869

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

870

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

871

" no intersect CONIC_VAL CONIC_VAL"

caryclark

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

[diff] [blame]

872

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

873

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

874

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

875

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

876

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

877

" 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"

878

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

879

" no intersect CUBIC_VAL LINE_VAL"

880

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

881

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

882

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

883

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

884

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

885

" 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"

886

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

887

" 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"

888

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

889

" no intersect CUBIC_VAL QUAD_VAL"

890

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

891

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

892

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

893

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

894

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

895

" 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"

896

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

897

" 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"

898

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

899

" no intersect CUBIC_VAL CUBIC_VAL"

900

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

901

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

902

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

903

" no self intersect CUBIC_VAL"

);

break;

case REC_TYPE_SORT:

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

908

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

909

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

910

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

911

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

912

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

913

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

914

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

915

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

916

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

917

" [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"

918

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

919

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

920

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

921

" [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"

922

);

923

if (found) {

924

record[1].push(hasDone);

925

record[1].push(hasUnorderable);

926

record[1].push(hasSmall);

927

record[1].push(hasTiny);

928

record[1].push(hasOperand);

929

record[1].push(hasStop);

930

}

931

break;

caryclark

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

[diff] [blame]

932

case REC_TYPE_TOP:

933

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

934

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

935

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

936

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

937

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

938

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

939

);

940

break;

caryclark

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

[diff] [blame]

941

case REC_TYPE_MARK:

942

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

caryclark

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

[diff] [blame]

943

" 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]

944

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

caryclark

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

[diff] [blame]

945

" 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]

946

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

947

" 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]

948

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

caryclark

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

[diff] [blame]

949

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

950

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

951

" 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"

952

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

953

" 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]

954

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

955

" 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]

956

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

957

" 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]

958

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

959

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

960

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

961

" 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]

962

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

963

" 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]

964

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

965

" 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]

966

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

caryclark

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

[diff] [blame]

967

" last segment=IDX span=IDX"

caryclark

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

[diff] [blame]

968

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

caryclark

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

[diff] [blame]

969

" last seg=IDX span=IDX"

970

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

971

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

972

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

973

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

974

);

caryclark

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

[diff] [blame]

975

break;

976

case REC_TYPE_OP:

977

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

978

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

979

found = true;

980

break;

981

}

caryclark

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

[diff] [blame]

982

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

caryclark

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

[diff] [blame]

983

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

caryclark

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

[diff] [blame]

984

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

caryclark

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

[diff] [blame]

985

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

986

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

987

);

988

break;

989

case REC_TYPE_UNKNOWN:

found = true;

break;

}

if (!found) {

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

995

}

996

}

997

if (recType != REC_TYPE_UNKNOWN) {

998

records.push(recType);

999

records.push(lastLineNo);

1000

records.push(record);

1001

}

1002

if (records.length >= 1) {

1003

tests[testIndex] = records;

1004

testLines[testIndex] = lines;

}

}

function init(test) {

1009

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

1010

if (!canvas.getContext) return;

1011

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

1012

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

1013

var unscaledWidth = window.innerWidth - 20;

1014

var unscaledHeight = window.innerHeight - 20;

1015

screenWidth = unscaledWidth;

1016

screenHeight = unscaledHeight;

1017

canvas.width = unscaledWidth * resScale;

1018

canvas.height = unscaledHeight * resScale;

1019

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

1020

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

1021

if (resScale != 1) {

1022

ctx.scale(resScale, resScale);

}

xmin = Infinity;

xmax = -Infinity;

ymin = Infinity;

ymax = -Infinity;

caryclark

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

[diff] [blame]

1028

hasPath = hasAlignedPath = hasComputedPath = false;

caryclark

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

[diff] [blame]

1029

firstActiveSpan = -1;

1030

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

1031

var recType = test[tIndex];

1032

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

1033

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

1034

throw "stop execution";

1035

}

1036

var records = test[tIndex + 2];

1037

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

1038

var fragType = records[recordIndex];

1039

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

1040

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

1041

throw "stop execution";

1042

}

1043

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]

1049

case REC_TYPE_ALIGNED:

1050

hasAlignedPath = true;

caryclark

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

[diff] [blame]

1051

case REC_TYPE_COMPUTED:

1052

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

1053

break;

1054

}

caryclark

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

[diff] [blame]

1055

if (REC_TYPE_COMPUTED == recType) {

1056

hasComputedPath = true;

1057

}

caryclark

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

[diff] [blame]

1058

case REC_TYPE_PATH:

caryclark

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

[diff] [blame]

1059

first = 1;

caryclark

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

[diff] [blame]

1060

switch (fragType) {

1061

case PATH_LINE:

caryclark

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

[diff] [blame]

1062

last = 5;

caryclark

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

[diff] [blame]

1063

break;

caryclark

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

[diff] [blame]

1064

case PATH_CONIC:

caryclark

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

[diff] [blame]

1065

case PATH_QUAD:

caryclark

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

[diff] [blame]

1066

last = 7;

caryclark

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

[diff] [blame]

1067

break;

1068

case PATH_CUBIC:

caryclark

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

[diff] [blame]

1069

last = 9;

caryclark

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

[diff] [blame]

1070

break;

1071

default:

caryclark

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

[diff] [blame]

1072

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

caryclark

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

[diff] [blame]

1073

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

1074

throw "stop execution";

1075

}

1076

if (recType == REC_TYPE_PATH) {

1077

hasPath = true;

1078

}

1079

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]

1086

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]

1094

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

caryclark

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

[diff] [blame]

1095

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

1096

throw "stop execution";

1097

}

1098

if (recType == REC_TYPE_PATH2) {

1099

hasPath = true;

1100

}

1101

break;

caryclark

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

[diff] [blame]

1102

case REC_TYPE_ACTIVE:

1103

if (firstActiveSpan < 0) {

1104

firstActiveSpan = tIndex;

}

first = 1;

switch (fragType) {

case ACTIVE_LINE_SPAN:

1109

last = 5;

1110

break;

caryclark

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

[diff] [blame]

1111

case ACTIVE_CONIC_SPAN:

caryclark

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

[diff] [blame]

1112

case ACTIVE_QUAD_SPAN:

1113

last = 7;

1114

break;

1115

case ACTIVE_CUBIC_SPAN:

last = 9;

break;

default:

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

1120

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]

1130

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);

1142

throw "stop execution";

1143

}

1144

break;

caryclark

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

[diff] [blame]

1145

case REC_TYPE_AFTERPART:

switch (fragType) {

case PATH_LINE:

last = 4;

break;

caryclark

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

[diff] [blame]

1150

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);

1159

throw "stop execution";

1160

}

1161

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;

1166

break;

1167

case INTERSECT_LINE_2:

1168

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

1169

break;

1170

case INTERSECT_LINE_NO:

1171

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

1172

break;

caryclark

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

[diff] [blame]

1173

case INTERSECT_CONIC_LINE:

1174

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

1175

break;

caryclark

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

[diff] [blame]

1176

case INTERSECT_QUAD_LINE:

1177

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

1178

break;

caryclark

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

[diff] [blame]

1179

case INTERSECT_CONIC_LINE_2:

1180

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

1181

break;

caryclark

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

[diff] [blame]

1182

case INTERSECT_QUAD_LINE_2:

1183

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

1184

break;

caryclark

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

[diff] [blame]

1185

case INTERSECT_CONIC_LINE_NO:

1186

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

1187

break;

caryclark

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

[diff] [blame]

1188

case INTERSECT_QUAD_LINE_NO:

1189

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

1190

break;

caryclark

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

[diff] [blame]

1191

case INTERSECT_CONIC:

1192

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

1193

break;

caryclark

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

[diff] [blame]

1194

case INTERSECT_QUAD:

1195

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

1196

break;

caryclark

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

[diff] [blame]

1197

case INTERSECT_CONIC_2:

1198

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

1199

break;

caryclark

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

[diff] [blame]

1200

case INTERSECT_QUAD_2:

1201

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

1202

break;

caryclark

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

[diff] [blame]

1203

case INTERSECT_CONIC_NO:

1204

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

1205

break;

caryclark

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

[diff] [blame]

1206

case INTERSECT_QUAD_NO:

1207

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

1208

break;

1209

case INTERSECT_SELF_CUBIC:

1210

first = 1; last = 9;

1211

break;

1212

case INTERSECT_SELF_CUBIC_NO:

1213

first = 0; last = 8;

1214

break;

1215

case INTERSECT_CUBIC_LINE:

1216

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

1217

break;

1218

case INTERSECT_CUBIC_LINE_2:

1219

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

1220

break;

1221

case INTERSECT_CUBIC_LINE_3:

1222

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

1223

break;

1224

case INTERSECT_CUBIC_LINE_NO:

1225

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

1226

break;

caryclark

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

[diff] [blame]

1227

case INTERSECT_CONIC_QUAD:

1228

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

1229

break;

1230

case INTERSECT_CONIC_QUAD_2:

1231

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

1232

break;

caryclark

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

[diff] [blame]

1233

case INTERSECT_CONIC_QUAD_3:

1234

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

1235

break;

1236

case INTERSECT_CONIC_QUAD_4:

1237

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

1238

break;

caryclark

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

[diff] [blame]

1239

case INTERSECT_CONIC_QUAD_NO:

1240

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

1241

break;

caryclark

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

[diff] [blame]

1242

case INTERSECT_CUBIC_QUAD:

1243

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

1244

break;

1245

case INTERSECT_CUBIC_QUAD_2:

1246

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

1247

break;

1248

case INTERSECT_CUBIC_QUAD_3:

1249

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

1250

break;

1251

case INTERSECT_CUBIC_QUAD_4:

1252

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

1253

break;

1254

case INTERSECT_CUBIC_QUAD_NO:

1255

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

1256

break;

1257

case INTERSECT_CUBIC:

1258

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

1259

break;

1260

case INTERSECT_CUBIC_2:

1261

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

1262

break;

1263

case INTERSECT_CUBIC_3:

1264

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

1265

break;

1266

case INTERSECT_CUBIC_4:

1267

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

1268

break;

1269

case INTERSECT_CUBIC_NO:

1270

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

1271

break;

1272

default:

1273

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

1274

throw "stop execution";

}

break;

default:

continue;

}

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

1281

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

1282

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

1283

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

1284

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

1285

}

1286

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

1287

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

1288

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

1289

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

1290

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

}

}

}

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

1295

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

1296

var recType = test[tIndex];

1297

var records = test[tIndex + 2];

1298

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

1299

var fragType = records[recordIndex];

1300

var frags = records[recordIndex + 1];

1301

switch (recType) {

1302

case REC_TYPE_ACTIVE_OP:

if (!draw_op) {

break;

}

{

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

1308

curve_extremes(curve, angleBounds);

}

break;

case REC_TYPE_ANGLE:

if (!draw_angle) {

break;

}

caryclark

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

[diff] [blame]

1315

{

caryclark

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

[diff] [blame]

1316

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

1317

curve_extremes(curve, angleBounds);

1318

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

1319

curve_extremes(curve, angleBounds);

1320

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

1321

}

1322

break;

caryclark

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

[diff] [blame]

1323

case REC_TYPE_COINCIDENCE:

1324

if (!draw_coincidence) {

break;

}

{

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

1329

curve_extremes(curve, angleBounds);

1330

}

1331

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) {

1337

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

1338

curve_extremes(curve, angleBounds);

1339

}

1340

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]);

1347

curve_extremes(curve, angleBounds);

1348

}

1349

break;

caryclark

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

[diff] [blame]

}

}

}

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

1354

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

1355

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

1356

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

1357

setScale(xmin, xmax, ymin, ymax);

1358

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

caryclark

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

[diff] [blame]

1359

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

caryclark

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

[diff] [blame]

1360

}

1361

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

draw_computed = 0;

}

}

caryclark

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

[diff] [blame]

1366

function curveByIDMatch(test, id, recMatch) {

caryclark

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

[diff] [blame]

1367

var tIndex = -3;

1368

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

caryclark

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

[diff] [blame]

1369

var recType = test[tIndex];

caryclark

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

[diff] [blame]

1370

if (recType == REC_TYPE_OP) {

1371

continue;

1372

}

caryclark

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

[diff] [blame]

1373

if (recType != recMatch) {

caryclark

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

[diff] [blame]

1374

return [];

1375

}

1376

var records = test[tIndex + 2];

1377

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

1378

var fragType = records[recordIndex];

1379

var frags = records[recordIndex + 1];

1380

if (frags[0] == id) {

1381

switch (fragType) {

caryclark

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

[diff] [blame]

1382

case PATH_LINE:

caryclark

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

[diff] [blame]

1383

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

caryclark

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

[diff] [blame]

1384

case PATH_QUAD:

caryclark

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

[diff] [blame]

1385

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

1386

frags[5], frags[6]];

caryclark

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

[diff] [blame]

1387

case PATH_CONIC:

1388

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

1389

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

caryclark

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

[diff] [blame]

1390

case PATH_CUBIC:

caryclark

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

[diff] [blame]

1391

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

1392

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

1393

}

1394

}

1395

}

caryclark

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

[diff] [blame]

}

return [];

}

caryclark

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

[diff] [blame]

1400

function curveByID(test, id) {

1401

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

1402

if (!result.length) {

1403

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]

1409

var tIndex = -3;

1410

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

caryclark

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

[diff] [blame]

1411

var recType = test[tIndex];

caryclark

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

[diff] [blame]

1412

if (recType == REC_TYPE_OP) {

1413

continue;

1414

}

caryclark

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

[diff] [blame]

1415

if (recType != recMatch) {

caryclark

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

[diff] [blame]

1416

return [];

1417

}

1418

var records = test[tIndex + 2];

1419

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

1420

var fragType = records[recordIndex];

1421

var frags = records[recordIndex + 1];

1422

if (frags[0] == id) {

1423

switch (fragType) {

caryclark

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

[diff] [blame]

1424

case PATH_LINE:

caryclark

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

[diff] [blame]

1425

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

caryclark

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

[diff] [blame]

1426

case PATH_QUAD:

caryclark

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

[diff] [blame]

1427

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

1428

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

caryclark

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

[diff] [blame]

1429

case PATH_CONIC:

1430

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

1431

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

caryclark

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

[diff] [blame]

1432

case PATH_CUBIC:

caryclark

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

[diff] [blame]

1433

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

1434

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

1435

}

1436

}

1437

}

caryclark

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

[diff] [blame]

}

return [];

}

caryclark

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

[diff] [blame]

1442

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

1443

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

1444

if (!result.length) {

1445

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]

1451

var tIndex = 0;

caryclark

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

[diff] [blame]

1452

while (tIndex < test.length) {

1453

var recType = test[tIndex];

caryclark

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

[diff] [blame]

1454

if (recType != recMatch) {

caryclark

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

[diff] [blame]

1455

++tIndex;

1456

continue;

caryclark

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

[diff] [blame]

1457

}

1458

var records = test[tIndex + 2];

1459

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

1460

var fragType = records[recordIndex];

1461

var frags = records[recordIndex + 1];

caryclark

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

[diff] [blame]

1462

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

1463

continue;

1464

}

caryclark

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

[diff] [blame]

1465

switch (fragType) {

caryclark

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

[diff] [blame]

1466

case PATH_LINE:

caryclark

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

[diff] [blame]

1467

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

1468

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

1469

continue;

1470

}

1471

return frags[0];

caryclark

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

[diff] [blame]

1472

case PATH_QUAD:

caryclark

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

[diff] [blame]

1473

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

1474

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

1475

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

1476

continue;

1477

}

1478

return frags[0];

caryclark

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

[diff] [blame]

1479

case PATH_CONIC:

1480

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

1481

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

1482

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

1483

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

1484

continue;

1485

}

1486

return frags[0];

caryclark

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

[diff] [blame]

1487

case PATH_CUBIC:

caryclark

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

[diff] [blame]

1488

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

1489

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

1490

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

1491

|| 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]

1502

function idByCurve(test, frag, type) {

1503

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

1504

if (!result.length) {

1505

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

}

return result;

}

caryclark

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

[diff] [blame]

1510

function curve_extremes(curve, bounds) {

caryclark

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

[diff] [blame]

1511

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

caryclark

ed0935a

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

[diff] [blame]

1512

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

caryclark

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

[diff] [blame]

1513

var x = curve[index];

1514

var y = curve[index + 1];

1515

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

1516

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

1517

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

1518

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

}

}

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

1523

var srcWidth = x1 - x0;

1524

var srcHeight = y1 - y0;

1525

var usableWidth = screenWidth;

1526

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

1527

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

1528

usableWidth -= (xDigits + yDigits) * 10;

1529

usableWidth -= decimal_places * 10;

if (draw_legend) {

usableWidth -= 40;

}

var hscale = usableWidth / srcWidth;

1534

var vscale = screenHeight / srcHeight;

1535

scale = Math.min(hscale, vscale);

1536

var invScale = 1 / scale;

1537

var sxmin = x0 - invScale * 5;

1538

var symin = y0 - invScale * 10;

1539

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

1540

var symax = y1 + invScale * 10;

1541

srcWidth = sxmax - sxmin;

1542

srcHeight = symax - symin;

1543

hscale = usableWidth / srcWidth;

1544

vscale = screenHeight / srcHeight;

1545

scale = Math.min(hscale, vscale);

srcLeft = sxmin;

srcTop = symin;

}

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

1551

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

1552

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

1553

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

1554

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

1555

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

1556

var _dist = dist * scale;

1557

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

1558

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

1559

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

var divisor = 4;

var endDist;

do {

var ends = [];

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

1565

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

1566

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

ends.push(px);

ends.push(py);

}

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

1571

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

1572

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)";

1585

ctx.beginPath();

1586

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

1587

ctx.stroke();

1588

var saveAlign = ctx.textAlign;

1589

var saveStyle = ctx.fillStyle;

1590

var saveFont = ctx.font;

1591

ctx.textAlign = "center";

1592

ctx.fillStyle = "black";

1593

ctx.font = "normal 24px Arial";

1594

divisor *= 0.8;

1595

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

1596

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

1597

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

1598

var _px = (px - srcLeft) * scale;

1599

var _py = (py - srcTop) * scale;

1600

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

1601

}

1602

ctx.textAlign = saveAlign;

1603

ctx.fillStyle = saveStyle;

ctx.font = saveFont;

}

function drawPoint(px, py, end) {

caryclark

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

[diff] [blame]

1608

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

1609

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

caryclark

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

[diff] [blame]

1610

var x = drawnPts[pts];

1611

var y = drawnPts[pts + 1];

1612

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

return;

}

}

drawnPts.push(px);

drawnPts.push(py);

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

1619

var _px = (px - srcLeft) * scale;

1620

var _py = (py - srcTop) * scale;

1621

ctx.beginPath();

1622

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";

1631

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

}

}

caryclark

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

[diff] [blame]

1635

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]

1649

function drawPoints(ptArray, curveType, drawControls) {

caryclark

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

[diff] [blame]

1650

var count = coordCount(curveType);

caryclark

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

[diff] [blame]

1651

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

1652

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

1653

continue;

1654

}

1655

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

}

}

function drawControlLines(curve, curveType, drawEnd) {

1660

if (curveType == PATH_LINE) {

1661

return;

1662

}

1663

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

1664

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

1665

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

1666

if (curveType == PATH_CUBIC) {

1667

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

1668

if (drawEnd > 1) {

1669

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

1670

if (drawEnd > 2) {

1671

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

1672

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

1673

}

1674

}

1675

} else if (drawEnd > 1) {

1676

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];

1687

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

break;

case PATH_QUAD:

var one_t = 1 - t;

var a = one_t * one_t;

1692

var b = 2 * one_t * t;

1693

var c = t * t;

1694

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

1695

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

1696

break;

caryclark

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

[diff] [blame]

1697

case PATH_CONIC:

1698

var one_t = 1 - t;

1699

var a = one_t * one_t;

1700

var b = 2 * one_t * t;

1701

var c = t * t;

1702

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

1703

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

1704

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

1705

xy.x /= d;

1706

xy.y /= d;

1707

break;

caryclark

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

[diff] [blame]

1708

case PATH_CUBIC:

1709

var one_t = 1 - t;

1710

var one_t2 = one_t * one_t;

1711

var a = one_t2 * one_t;

1712

var b = 3 * one_t2 * t;

1713

var t2 = t * t;

1714

var c = 3 * one_t * t2;

1715

var d = t2 * t;

1716

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

1717

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]

1722

caryclark

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

[diff] [blame]

1723

function drawPointAtT(curve, curveType) {

1724

var x, y;

1725

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

1726

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

1727

if (!draw_intersectT) {

1728

return;

1729

}

1730

ctx.fillStyle = "red";

1731

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

1732

}

1733

1734

function drawTAtPointUp(px, py, t) {

1735

var label = t.toFixed(decimal_places);

1736

var _px = (px - srcLeft)* scale;

1737

var _py = (py - srcTop) * scale;

1738

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

1739

}

1740

1741

function drawTAtPointDown(px, py, t) {

1742

var label = t.toFixed(decimal_places);

1743

var _px = (px - srcLeft)* scale;

1744

var _py = (py - srcTop) * scale;

1745

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

1746

}

1747

1748

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

1749

if (collect_bounds) {

1750

if (focus_enabled) {

1751

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

1752

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

1753

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

1754

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

}

return true;

}

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

1759

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

1760

&& 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) {

1772

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

return;

}

ctx.beginPath();

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

1777

(y1 - srcTop) * scale);

1778

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

1779

(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) {

1796

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,

1806

(ay - srcTop) * scale);

1807

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

1808

(by - srcTop) * scale);

ctx.stroke();

}

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

1813

if (collect_bounds) {

1814

if (focus_enabled) {

1815

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

1816

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

1817

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

1818

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

}

return true;

}

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

1823

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

1824

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

1825

&& 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) {

1839

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

return;

}

ctx.beginPath();

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

1844

(y1 - srcTop) * scale);

1845

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

1846

(y2 - srcTop) * scale,

1847

(x3 - srcLeft) * scale,

1848

(y3 - srcTop) * scale);

ctx.stroke();

}

function interp(A, B, t) {

1853

return A + (B - A) * t;

1854

}

1855

1856

function interp_quad_coords(x1, x2, x3, t)

1857

{

1858

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

1859

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

1860

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

return abc;

}

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

1865

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

1866

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

1867

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

1868

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

1869

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

1870

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

1871

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

1872

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

1873

var array = [

1874

ax, ay, bx, by, cx, cy

];

return array;

}

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

1880

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,

1892

(ay - srcTop) * scale);

1893

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

1894

(by - srcTop) * scale,

1895

(cx - srcLeft) * scale,

1896

(cy - srcTop) * scale);

ctx.stroke();

}

caryclark

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

[diff] [blame]

1900

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

1901

if (collect_bounds) {

1902

if (focus_enabled) {

1903

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

1904

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

1905

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

1906

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

}

return true;

}

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

1911

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

caryclark

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

[diff] [blame]

1912

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

1913

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

caryclark

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

[diff] [blame]

1914

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

return true;

}

}

drawnConics.push(x1);

1919

drawnConics.push(y1);

1920

drawnConics.push(x2);

1921

drawnConics.push(y2);

1922

drawnConics.push(x3);

1923

drawnConics.push(y3);

drawnCubics.push(w);

return false;

}

var kMaxConicToQuadPOW2 = 5;

1929

1930

function computeQuadPOW2(curve, tol) {

1931

var a = curve[6] - 1;

1932

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

1933

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

1934

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

1935

1936

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

1937

var pow2;

1938

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

if (error <= tol) {

break;

}

error *= 0.25;

}

return pow2;

}

function subdivide_w_value(w) {

1948

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

1949

}

1950

1951

function chop(curve, part1, part2) {

1952

var w = curve[6];

1953

var scale = 1 / (1 + w);

1954

part1[0] = curve[0];

1955

part1[1] = curve[1];

1956

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

1957

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

1958

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

1959

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

1960

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

1961

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

1962

part2[4] = curve[4];

1963

part2[5] = curve[5];

1964

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

1965

}

1966

1967

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 = [];

1975

chop(curve, part1, part2);

1976

--level;

1977

subdivide(part1, level, pts);

1978

subdivide(part2, level, pts);

}

}

function chopIntoQuadsPOW2(curve, pow2, pts) {

1983

subdivide(curve, pow2, pts);

return 1 << pow2;

}

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

1988

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

return;

}

ctx.beginPath();

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

1993

(y1 - srcTop) * scale);

1994

var tol = 1 / scale;

1995

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

1996

var pow2 = computeQuadPOW2(curve, tol);

1997

var pts = [];

1998

chopIntoQuadsPOW2(curve, pow2, pts);

1999

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

2000

ctx.quadraticCurveTo(

2001

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

2002

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

}

ctx.stroke();

}

function conic_eval_numerator(x1, x2, x3, w, t) {

2008

var src2w = x2 * w;

2009

var C = x1;

2010

var A = x3 - 2 * src2w + C;

2011

var B = 2 * (src2w - C);

2012

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;

2021

}

2022

2023

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

2024

var ax = conic_eval_numerator(x1, x2, x3, w, t1);

2025

var ay = conic_eval_numerator(y1, y2, y3, w, t1);

2026

var az = conic_eval_denominator(w, t1);

2027

var midT = (t1 + t2) / 2;

2028

var dx = conic_eval_numerator(x1, x2, x3, w, midT);

2029

var dy = conic_eval_numerator(y1, y2, y3, w, midT);

2030

var dz = conic_eval_denominator(w, midT);

2031

var cx = conic_eval_numerator(x1, x2, x3, w, t2);

2032

var cy = conic_eval_numerator(y1, y2, y3, w, t2);

2033

var cz = conic_eval_denominator(w, t2);

2034

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

2035

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

2036

var bz = 2 * dz - (az + cz) / 2;

2037

var dt = t2 - t1;

2038

var dt_1 = 1 - dt;

caryclark

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

[diff] [blame]

2039

var array = [

caryclark

ed0935a

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

[diff] [blame]

2040

ax / az, ay / az, bx / bz, by / bz, cx / cz, cy / cz, 0

caryclark

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

[diff] [blame]

2041

];

caryclark

ed0935a

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

[diff] [blame]

2042

var dMidAC = { x:(array[0] + array[4]) / 2, y:(array[1] + array[5]) / 2 };

2043

var dMid = { x:dx / dz, y:dy / dz };

2044

var dWNumer = { x:dMidAC.x - dMid.x, y:dMidAC.y - dMid.y };

2045

var dWDenom = { x:dMid.x - array[2], y:dMid.y - array[3] };

2046

var partW = Math.sqrt(dWNumer.x * dWNumer.x + dWNumer.y * dWNumer.y)

2047

/ Math.sqrt(dWDenom.x * dWDenom.x + dWDenom.y * dWDenom.y);

2048

array[6] = partW;

caryclark

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

[diff] [blame]

2049

return array;

2050

}

caryclark

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

[diff] [blame]

2051

caryclark

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

[diff] [blame]

2052

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

2053

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_);

2062

}

2063

caryclark

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

[diff] [blame]

2064

function alreadyDrawnCubic(x1, y1, x2, y2, x3, y3, x4, y4) {

2065

if (collect_bounds) {

2066

if (focus_enabled) {

2067

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

2068

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

2069

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

2070

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

}

return true;

}

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

2075

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

caryclark

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

[diff] [blame]

2076

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

2077

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

caryclark

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

[diff] [blame]

2078

&& x4 == drawnCubics[pts + 6] && y4 == drawnCubics[pts + 7]) {

return true;

}

}

drawnCubics.push(x1);

2083

drawnCubics.push(y1);

2084

drawnCubics.push(x2);

2085

drawnCubics.push(y2);

2086

drawnCubics.push(x3);

2087

drawnCubics.push(y3);

2088

drawnCubics.push(x4);

2089

drawnCubics.push(y4);

return false;

}

function drawCubic(x1, y1, x2, y2, x3, y3, x4, y4) {

2094

if (alreadyDrawnCubic(x1, y1, x2, y2, x3, y3, x4, y4)) {

return;

}

ctx.beginPath();

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

2099

(y1 - srcTop) * scale);

2100

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

2101

(y2 - srcTop) * scale,

2102

(x3 - srcLeft) * scale,

2103

(y3 - srcTop) * scale,

2104

(x4 - srcLeft) * scale,

2105

(y4 - srcTop) * scale);

ctx.stroke();

}

function interp_cubic_coords(x1, x2, x3, x4, t)

2110

{

2111

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

2112

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

2113

var cd = interp(x3, x4, t);

2114

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

2115

var bcd = interp(bc, cd, t);

2116

var abcd = interp(abc, bcd, t);

return abcd;

}

function cubicPartial(x1, y1, x2, y2, x3, y3, x4, y4, t1, t2) {

2121

var ax = interp_cubic_coords(x1, x2, x3, x4, t1);

2122

var ay = interp_cubic_coords(y1, y2, y3, y4, t1);

2123

var ex = interp_cubic_coords(x1, x2, x3, x4, (t1*2+t2)/3);

2124

var ey = interp_cubic_coords(y1, y2, y3, y4, (t1*2+t2)/3);

2125

var fx = interp_cubic_coords(x1, x2, x3, x4, (t1+t2*2)/3);

2126

var fy = interp_cubic_coords(y1, y2, y3, y4, (t1+t2*2)/3);

2127

var dx = interp_cubic_coords(x1, x2, x3, x4, t2);

2128

var dy = interp_cubic_coords(y1, y2, y3, y4, t2);

2129

var mx = ex * 27 - ax * 8 - dx;

2130

var my = ey * 27 - ay * 8 - dy;

2131

var nx = fx * 27 - ax - dx * 8;

2132

var ny = fy * 27 - ay - dy * 8;

2133

var bx = (mx * 2 - nx) / 18;

2134

var by = (my * 2 - ny) / 18;

2135

var cx = (nx * 2 - mx) / 18;

2136

var cy = (ny * 2 - my) / 18;

2137

var array = [

2138

ax, ay, bx, by, cx, cy, dx, dy

2139

];

2140

return array;

2141

}

caryclark

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

[diff] [blame]

2142

caryclark

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

[diff] [blame]

2143

function drawCubicPartial(x1, y1, x2, y2, x3, y3, x4, y4, t1, t2) {

2144

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,

2158

(ay - srcTop) * scale);

2159

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

2160

(by - srcTop) * scale,

2161

(cx - srcLeft) * scale,

2162

(cy - srcTop) * scale,

2163

(dx - srcLeft) * scale,

2164

(dy - srcTop) * scale);

ctx.stroke();

}

function drawCurve(c) {

2169

switch (c.length) {

2170

case 4:

2171

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

2172

break;

2173

case 6:

2174

drawQuad(c[0], c[1], c[2], c[3], c[4], c[5]);

2175

break;

caryclark

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

[diff] [blame]

2176

case 7:

2177

drawConicWithQuads(c[0], c[1], c[2], c[3], c[4], c[5], c[6]);

2178

break;

caryclark

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

[diff] [blame]

2179

case 8:

2180

drawCubic(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]);

break;

}

}

function boundsWidth(pts) {

2186

var min = pts[0];

2187

var max = pts[0];

caryclark

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

[diff] [blame]

2188

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

2189

for (var idx = 2; idx < length; idx += 2) {

caryclark

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

[diff] [blame]

2190

min = Math.min(min, pts[idx]);

2191

max = Math.max(max, pts[idx]);

}

return max - min;

}

function boundsHeight(pts) {

2197

var min = pts[1];

2198

var max = pts[1];

caryclark

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

[diff] [blame]

2199

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

2200

for (var idx = 3; idx < length; idx += 2) {

caryclark

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

[diff] [blame]

2201

min = Math.min(min, pts[idx]);

2202

max = Math.max(max, pts[idx]);

}

return max - min;

}

function tangent(pts) {

2208

var dx = pts[2] - pts[0];

2209

var dy = pts[3] - pts[1];

2210

if (dx == 0 && dy == 0 && pts.length > 4) {

2211

dx = pts[4] - pts[0];

2212

dy = pts[5] - pts[1];

caryclark

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

[diff] [blame]

2213

if (dx == 0 && dy == 0 && pts.length == 8) {

caryclark

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

[diff] [blame]

2214

dx = pts[6] - pts[0];

2215

dy = pts[7] - pts[1];

2216

}

2217

}

2218

return Math.atan2(-dy, dx);

2219

}

2220

2221

function hodograph(cubic) {

2222

var hodo = [];

2223

hodo[0] = 3 * (cubic[2] - cubic[0]);

2224

hodo[1] = 3 * (cubic[3] - cubic[1]);

2225

hodo[2] = 3 * (cubic[4] - cubic[2]);

2226

hodo[3] = 3 * (cubic[5] - cubic[3]);

2227

hodo[4] = 3 * (cubic[6] - cubic[4]);

2228

hodo[5] = 3 * (cubic[7] - cubic[5]);

return hodo;

}

function hodograph2(cubic) {

2233

var quad = hodograph(cubic);

2234

var hodo = [];

2235

hodo[0] = 2 * (quad[2] - quad[0]);

2236

hodo[1] = 2 * (quad[3] - quad[1]);

2237

hodo[2] = 2 * (quad[4] - quad[2]);

2238

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];

2265

}

2266

2267

function add_valid_ts(s, realRoots, t) {

2268

var foundRoots = 0;

2269

for (var index = 0; index < realRoots; ++index) {

2270

var tValue = s[index];

2271

if (tValue >= 0 && tValue <= 1) {

2272

for (var idx2 = 0; idx2 < foundRoots; ++idx2) {

2273

if (t[idx2] != tValue) {

2274

t[foundRoots++] = tValue;

}

}

}

}

return foundRoots;

}

function quadraticRootsValidT(a, b, c, t) {

2283

var s = [];

2284

var realRoots = quadraticRootsReal(A, B, C, s);

2285

var foundRoots = add_valid_ts(s, realRoots, t);

2286

return foundRoots != 0;

2287

}

2288

2289

function find_cubic_inflections(cubic, tValues) {

2290

var Ax = src[2] - src[0];

2291

var Ay = src[3] - src[1];

2292

var Bx = src[4] - 2 * src[2] + src[0];

2293

var By = src[5] - 2 * src[3] + src[1];

2294

var Cx = src[6] + 3 * (src[2] - src[4]) - src[0];

2295

var Cy = src[7] + 3 * (src[3] - src[5]) - src[1];

2296

return quadraticRootsValidT(Bx * Cy - By * Cx, (Ax * Cy - Ay * Cx),

2297

Ax * By - Ay * Bx, tValues);

2298

}

2299

2300

function dxy_at_t(curve, type, t) {

2301

var dxy = {};

Cary Clark

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

[diff] [blame]

2302

if (type == PATH_LINE) {

2303

dxy.x = curve[2] - curve[0];

2304

dxy.y = curve[3] - curve[1];

2305

} 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];

2310

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

caryclark

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

[diff] [blame]

2311

} else if (type == PATH_CONIC) {

2312

var p20x = curve[4] - curve[0];

2313

var p20y = curve[5] - curve[1];

2314

var p10xw = (curve[2] - curve[0]) * curve[6];

2315

var p10yw = (curve[3] - curve[1]) * curve[6];

2316

var coeff0x = curve[6] * p20x - p20x;

2317

var coeff0y = curve[6] * p20y - p20y;

2318

var coeff1x = p20x - 2 * p10xw;

2319

var coeff1y = p20y - 2 * p10yw;

2320

dxy.x = t * (t * coeff0x + coeff1x) + p10xw;

2321

dxy.y = t * (t * coeff0y + coeff1y) + p10yw;

caryclark

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

[diff] [blame]

2322

} 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]

2338

function dpt_at_t(curve, t) {

Cary Clark

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

[diff] [blame]

2339

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

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2340

return dxy_at_t(curve, type, t);

Cary Clark

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

[diff] [blame]

2341

}

2342

caryclark

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

[diff] [blame]

2343

function drawLabel(num, px, py) {

2344

ctx.beginPath();

2345

ctx.arc(px, py, 8, 0, Math.PI*2, true);

2346

ctx.closePath();

2347

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

2348

ctx.lineWidth = num == 0 || num == 3 ? 2 : 1;

2349

ctx.stroke();

2350

ctx.fillStyle = "black";

2351

ctx.font = "normal 10px Arial";

2352

// ctx.rotate(0.001);

2353

ctx.fillText(num, px - 2, py + 3);

2354

// ctx.rotate(-0.001);

2355

}

2356

2357

function drawLabelX(ymin, num, loc) {

2358

var px = (loc - srcLeft) * scale;

2359

var py = (ymin - srcTop) * scale - 20;

2360

drawLabel(num, px, py);

2361

}

2362

2363

function drawLabelY(xmin, num, loc) {

2364

var px = (xmin - srcLeft) * scale - 20;

2365

var py = (loc - srcTop) * scale;

2366

drawLabel(num, px, py);

2367

}

2368

2369

function drawHodoOrigin(hx, hy, hMinX, hMinY, hMaxX, hMaxY) {

2370

ctx.beginPath();

2371

ctx.moveTo(hx, hy - 100);

2372

ctx.lineTo(hx, hy);

2373

ctx.strokeStyle = hMinY < 0 ? "green" : "blue";

ctx.stroke();

ctx.beginPath();

ctx.moveTo(hx, hy);

ctx.lineTo(hx, hy + 100);

2378

ctx.strokeStyle = hMaxY > 0 ? "green" : "blue";

2379

ctx.stroke();

2380

ctx.beginPath();

2381

ctx.moveTo(hx - 100, hy);

2382

ctx.lineTo(hx, hy);

2383

ctx.strokeStyle = hMinX < 0 ? "green" : "blue";

ctx.stroke();

ctx.beginPath();

ctx.moveTo(hx, hy);

ctx.lineTo(hx + 100, hy);

2388

ctx.strokeStyle = hMaxX > 0 ? "green" : "blue";

ctx.stroke();

}

function scalexy(x, y, mag) {

2393

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

return mag / length;

}

caryclark

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

[diff] [blame]

2397

function drawArrow(x, y, dx, dy, s) {

2398

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);

2403

x += dx;

2404

y += dy;

2405

ctx.lineTo((x - srcLeft) * scale, (y - srcTop) * scale);

2406

dx /= 10;

2407

dy /= 10;

2408

ctx.lineTo((x - dy - srcLeft) * scale, (y + dx - srcTop) * scale);

2409

ctx.lineTo((x + dx * 2 - srcLeft) * scale, (y + dy * 2 - srcTop) * scale);

2410

ctx.lineTo((x + dy - srcLeft) * scale, (y - dx - srcTop) * scale);

2411

ctx.lineTo((x - srcLeft) * scale, (y - srcTop) * scale);

2412

ctx.strokeStyle = "rgba(0,75,0, 0.4)";

ctx.stroke();

}

function x_at_t(curve, t) {

2417

var one_t = 1 - t;

2418

if (curve.length == 4) {

2419

return one_t * curve[0] + t * curve[2];

2420

}

2421

var one_t2 = one_t * one_t;

2422

var t2 = t * t;

2423

if (curve.length == 6) {

2424

return one_t2 * curve[0] + 2 * one_t * t * curve[2] + t2 * curve[4];

2425

}

caryclark

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

[diff] [blame]

2426

if (curve.length == 7) {

2427

return (one_t2 * curve[0] + 2 * one_t * t * curve[2] * curve[6] + t2 * curve[4])

2428

/ (one_t2 +2 * one_t * t * curve[6] + t2);

2429

}

caryclark

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

[diff] [blame]

2430

var a = one_t2 * one_t;

2431

var b = 3 * one_t2 * t;

2432

var c = 3 * one_t * t2;

2433

var d = t2 * t;

2434

return a * curve[0] + b * curve[2] + c * curve[4] + d * curve[6];

2435

}

2436

2437

function y_at_t(curve, t) {

2438

var one_t = 1 - t;

2439

if (curve.length == 4) {

2440

return one_t * curve[1] + t * curve[3];

2441

}

2442

var one_t2 = one_t * one_t;

2443

var t2 = t * t;

2444

if (curve.length == 6) {

2445

return one_t2 * curve[1] + 2 * one_t * t * curve[3] + t2 * curve[5];

2446

}

caryclark

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

[diff] [blame]

2447

if (curve.length == 7) {

2448

return (one_t2 * curve[1] + 2 * one_t * t * curve[3] * curve[6] + t2 * curve[5])

2449

/ (one_t2 +2 * one_t * t * curve[6] + t2);

2450

}

caryclark

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

[diff] [blame]

2451

var a = one_t2 * one_t;

2452

var b = 3 * one_t2 * t;

2453

var c = 3 * one_t * t2;

2454

var d = t2 * t;

2455

return a * curve[1] + b * curve[3] + c * curve[5] + d * curve[7];

2456

}

2457

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2458

function pt_at_t(curve, t) {

2459

var pt = {};

2460

pt.x = x_at_t(curve, t);

2461

pt.y = y_at_t(curve, t);

2462

return pt;

Cary Clark

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

[diff] [blame]

2463

}

2464

2465

function drawOrder(curve, t, label) {

2466

var px = x_at_t(curve, t);

2467

var py = y_at_t(curve, t);

caryclark

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

[diff] [blame]

2468

var _px = (px - srcLeft) * scale;

2469

var _py = (py - srcTop) * scale;

2470

ctx.beginPath();

2471

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

2472

ctx.closePath();

2473

ctx.fillStyle = "white";

2474

ctx.fill();

2475

if (label == 'L') {

2476

ctx.strokeStyle = "rgba(255,0,0, 1)";

2477

ctx.fillStyle = "rgba(255,0,0, 1)";

2478

} else {

2479

ctx.strokeStyle = "rgba(0,0,255, 1)";

2480

ctx.fillStyle = "rgba(0,0,255, 1)";

2481

}

2482

ctx.stroke();

2483

ctx.font = "normal 16px Arial";

2484

ctx.textAlign = "center";

2485

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

2486

ctx.font = "normal 10px Arial";

2487

}

2488

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2489

function drawVisibleOrder(curve, label) {

2490

var s = pt_at_t(curve, 0);

2491

var e = pt_at_t(curve, 1);

2492

var sOn = ptOnScreen(s);

2493

var eOn = ptOnScreen(e);

2494

var defaultT = 0.85;

2495

if (sOn && eOn)

2496

return drawOrder(curve, defaultT, label);

2497

if (sOn || eOn) {

2498

if (eOn) {

2499

defaultT = 1 - defaultT;

2500

}

2501

var step = sOn ? -defaultT / 2 : (1 - defaultT) / 2;

var t = defaultT;

var tries = 16;

do {

var mid = pt_at_t(curve, t);

2506

if (ptOnScreen(mid))

2507

return drawOrder(curve, t, label);

2508

t += step;

2509

step /= 2;

2510

} while (--tries > 0);

2511

drawOrder(curve, defaultT, label);

2512

}

2513

// scattershot until we find a visible point

2514

var denom = 2; // visit odd number num / denom to hit unique pts

2515

var tries = 6; // tries 1/2, 1/4, 3/4, 1/8, 3/8, 5/8, 7/8, 1/16 ...

2516

do {

2517

for (var numer = 1; numer < denom; numer += 2) {

2518

var t = numer / denom + 0.1;

if (t >= 1) {

break;

}

var mid = pt_at_t(curve, t);

2523

if (ptOnScreen(mid))

2524

return drawOrder(curve, t, label);

2525

}

2526

denom *= 2;

2527

} while (--tries > 0);

2528

drawOrder(curve, defaultT, label);

Cary Clark

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

[diff] [blame]

2529

}

2530

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2531

function set_length(pt, newLen) {

2532

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

2533

var scale = newLen / len;

2534

var newPt = { x: pt.x * scale, y: pt.y * scale };

2535

return newPt;

Cary Clark

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

[diff] [blame]

2536

}

2537

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2538

function drawDirection(curve, t) {

Cary Clark

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

[diff] [blame]

2539

var d = dpt_at_t(curve, t);

2540

d = set_length(d, 16);

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2541

var pt = localToGlobal(pt_at_t(curve, t));

Cary Clark

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

[diff] [blame]

2542

ctx.beginPath();

2543

ctx.moveTo(pt.x - d.y, pt.y + d.x);

2544

ctx.lineTo(pt.x + d.x, pt.y + d.y);

2545

ctx.lineTo(pt.x + d.y, pt.y - d.x);

2546

ctx.strokeStyle = "rgba(0,75,0, 0.4)";

ctx.stroke();

}

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2550

function drawVisibleDirection(curve) {

2551

var s = pt_at_t(curve, 0);

2552

var e = pt_at_t(curve, 1);

2553

var sOn = ptOnScreen(s);

2554

var eOn = ptOnScreen(e);

2555

var defaultT = 0.65;

2556

if (sOn && eOn) {

2557

return drawDirection(curve, defaultT);

}

if (sOn || eOn) {

if (eOn) {

defaultT = 1 - defaultT;

2562

}

2563

var step = sOn ? -defaultT / 2 : (1 - defaultT) / 2;

var t = defaultT;

var tries = 16;

do {

var mid = pt_at_t(curve, t);

2568

if (ptOnScreen(mid))

2569

return drawDirection(curve, t);

2570

t += step;

2571

step /= 2;

2572

} while (--tries > 0);

2573

drawDirection(curve, defaultT);

2574

}

2575

// scattershot until we find a visible point

2576

var denom = 2; // visit odd number num / denom to hit unique pts

2577

var tries = 6; // tries 1/2, 1/4, 3/4, 1/8, 3/8, 5/8, 7/8, 1/16 ...

2578

do {

2579

for (var numer = 1; numer < denom; numer += 2) {

2580

var t = numer / denom + 0.1;

if (t >= 1) {

break;

}

var mid = pt_at_t(curve, t);

2585

if (ptOnScreen(mid))

2586

return drawDirection(curve, t);

2587

}

2588

denom *= 2;

2589

} while (--tries > 0);

2590

drawDirection(curve, defaultT);

Cary Clark

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

[diff] [blame]

2591

}

2592

2593

function drawID(curve, t, id) {

2594

var px = x_at_t(curve, t);

2595

var py = y_at_t(curve, t);

caryclark

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

[diff] [blame]

2596

var _px = (px - srcLeft) * scale;

2597

var _py = (py - srcTop) * scale;

2598

draw_id_at(id, _px, _py);

2599

}

2600

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2601

function localToGlobal(local) {

2602

var global = {};

2603

global.x = (local.x - srcLeft) * scale;

2604

global.y = (local.y - srcTop) * scale;

2605

return global;

Cary Clark

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

[diff] [blame]

2606

}

2607

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2608

function ptOnScreen(local) {

2609

var pt = localToGlobal(local);

2610

return 10 <= pt.x && pt.x <= screenWidth - 10

2611

&& 10 <= pt.y && pt.y <= screenHeight - 10;

Cary Clark

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

[diff] [blame]

2612

}

2613

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2614

function drawVisibleID(curve, defaultT, id) {

2615

// determine if either or both ends are visible

2616

var s = pt_at_t(curve, 0);

2617

var e = pt_at_t(curve, 1);

2618

var sOn = ptOnScreen(s);

2619

var eOn = ptOnScreen(e);

2620

if (sOn && eOn)

2621

return drawID(curve, defaultT, id);

2622

if (sOn || eOn) {

2623

var step = sOn ? -defaultT / 2 : (1 - defaultT) / 2;

var t = defaultT;

var tries = 16;

do {

var mid = pt_at_t(curve, t);

2628

if (ptOnScreen(mid))

2629

return drawID(curve, t, id);

2630

t += step;

2631

step /= 2;

2632

} while (--tries > 0);

2633

drawID(curve, defaultT, id);

2634

}

2635

// scattershot until we find a visible point

2636

var denom = 2; // visit odd number num / denom to hit unique pts

2637

var tries = 6; // tries 1/2, 1/4, 3/4, 1/8, 3/8, 5/8, 7/8, 1/16 ...

2638

do {

2639

for (var numer = 1; numer < denom; numer += 2) {

2640

var t = numer / denom;

2641

var mid = pt_at_t(curve, t);

2642

if (ptOnScreen(mid))

2643

return drawID(curve, t, id);

2644

}

2645

denom *= 2;

2646

} while (--tries > 0);

2647

drawID(curve, defaultT, id);

Cary Clark

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

[diff] [blame]

2648

}

2649

caryclark

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

[diff] [blame]

2650

function draw_id_at(id, _px, _py) {

2651

ctx.beginPath();

2652

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

2653

ctx.closePath();

2654

ctx.fillStyle = "white";

2655

ctx.fill();

2656

ctx.strokeStyle = "rgba(127,127,0, 1)";

2657

ctx.fillStyle = "rgba(127,127,0, 1)";

2658

ctx.stroke();

2659

ctx.font = "normal 16px Arial";

2660

ctx.textAlign = "center";

2661

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

2662

ctx.font = "normal 10px Arial";

2663

}

2664

2665

function drawLinePartialID(id, x1, y1, x2, y2, t1, t2) {

2666

var curve = [x1, y1, x2, y2];

2667

drawCurvePartialID(id, curve, t1, t2);

2668

}

2669

caryclark

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

[diff] [blame]

2670

function drawLineID(id, x1, y1, x2, y2) {

2671

drawLinePartialID(id, x1, y1, x2, y2, 0, 1);

2672

}

2673

caryclark

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

[diff] [blame]

2674

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

2675

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

2676

drawCurvePartialID(id, curve, t1, t2);

2677

}

2678

caryclark

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

[diff] [blame]

2679

function drawQuadID(id, x1, y1, x2, y2, x3, y3) {

2680

drawQuadPartialID(id, x1, y1, x2, y2, x3, y3, 0, 1);

2681

}

2682

caryclark

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

[diff] [blame]

2683

function drawConicPartialID(id, x1, y1, x2, y2, x3, y3, w, t1, t2) {

2684

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

2685

drawCurvePartialID(id, curve, t1, t2);

2686

}

2687

caryclark

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

[diff] [blame]

2688

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

2689

drawConicPartialID(id, x1, y1, x2, y2, x3, y3, w, 0, 1);

2690

}

2691

caryclark

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

[diff] [blame]

2692

function drawCubicPartialID(id, x1, y1, x2, y2, x3, y3, x4, y4, t1, t2) {

2693

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

2694

drawCurvePartialID(id, curve, t1, t2);

2695

}

2696

caryclark

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

[diff] [blame]

2697

function drawCubicID(id, x1, y1, x2, y2, x3, y3, x4, y4) {

2698

drawCubicPartialID(id, x1, y1, x2, y2, x3, y3, x4, y4, 0, 1);

2699

}

2700

caryclark

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

[diff] [blame]

2701

function drawCurvePartialID(id, curve, t1, t2) {

Cary Clark

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

[diff] [blame]

2702

drawVisibleID(curve, (t1 + t2) / 2, id);

caryclark

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

[diff] [blame]

2703

}

2704

2705

function drawCurveSpecials(test, curve, type) {

2706

if (pt_labels) {

2707

drawPoints(curve, type, pt_labels == 2);

2708

}

2709

if (control_lines != 0) {

2710

drawControlLines(curve, type, control_lines);

2711

}

2712

if (curve_t) {

2713

drawPointAtT(curve, type);

2714

}

2715

if (draw_midpoint) {

2716

var mid = pointAtT(curve, type, 0.5);

2717

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

2718

}

2719

if (draw_id) {

2720

var id = idByCurve(test, curve, type);

2721

if (id >= 0) {

Cary Clark

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

[diff] [blame]

2722

drawVisibleID(curve, 0.5, id);

caryclark

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

[diff] [blame]

2723

}

2724

}

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

2725

if (draw_direction) {

2726

drawVisibleDirection(curve);

Cary Clark

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

[diff] [blame]

2727

}

caryclark

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

[diff] [blame]

2728

if (type == PATH_LINE) {

2729

return;

2730

}

2731

if (draw_deriviatives > 0) {

2732

var d = dxy_at_t(curve, type, 0);

caryclark

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

[diff] [blame]

2733

drawArrow(curve[0], curve[1], d.x, d.y, 1);

caryclark

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

[diff] [blame]

2734

if (draw_deriviatives == 2) {

2735

d = dxy_at_t(curve, type, 1);

2736

if (type == PATH_CUBIC) {

caryclark

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

[diff] [blame]

2737

drawArrow(curve[6], curve[7], d.x, d.y, 1);

caryclark

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

[diff] [blame]

2738

} else {

caryclark

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

[diff] [blame]

2739

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);

2744

d = dxy_at_t(curve, type, 0.5);

caryclark

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

[diff] [blame]

2745

drawArrow(mid.x, mid.y, d.x, d.y, 1);

caryclark

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

[diff] [blame]

2746

}

2747

}

2748

if (type != PATH_CUBIC) {

2749

return;

2750

}

caryclark

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

[diff] [blame]

2751

if (draw_sequence) {

2752

var ymin = Math.min(curve[1], curve[3], curve[5], curve[7]);

2753

for (var i = 0; i < 8; i+= 2) {

2754

drawLabelX(ymin, i >> 1, curve[i]);

2755

}

2756

var xmin = Math.min(curve[0], curve[2], curve[4], curve[6]);

2757

for (var i = 1; i < 8; i+= 2) {

2758

drawLabelY(xmin, i >> 1, curve[i]);

}

}

}

function logCurves(test) {

2764

for (curves in test) {

2765

var curve = test[curves];

dumpCurve(curve);

}

}

function curveToString(curve) {

2771

var str = "{{";

caryclark

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

[diff] [blame]

2772

var length = curve.length == 7 ? 6 : curve.length;

2773

if (curve.length == 7) {

2774

str += "{";

2775

}

2776

for (i = 0; i < length; i += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2777

str += curve[i].toFixed(decimal_places) + "," + curve[i + 1].toFixed(decimal_places);

2778

if (i < curve.length - 2) {

2779

str += "}, {";

2780

}

2781

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2782

str += "}";

2783

if (curve.length == 7) {

2784

str += "}, " + curve[6].toFixed(decimal_places);

2785

}

2786

str += "}";

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

return str;

}

function dumpCurve(curve) {

2791

console.log(curveToString(curve));

2792

}

2793

2794

function draw(test, lines, title) {

2795

ctx.fillStyle = "rgba(0,0,0, 0.1)";

2796

ctx.font = "normal 50px Arial";

2797

ctx.textAlign = "left";

2798

ctx.fillText(title, 50, 50);

2799

ctx.font = "normal 10px Arial";

2800

ctx.lineWidth = "1.001"; "0.999";

2801

var secondPath = test.length;

var closeCount = 0;

logStart = -1;

logRange = 0;

// find last active rec type at this step

2806

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]

2811

var lastCoin = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2812

var lastSect = 0;

2813

var lastSort = 0;

2814

var lastMark = 0;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2815

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]

2822

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]

2827

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]

2832

topMax = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2833

markMax = 0;

2834

lastIndex = test.length - 3;

2835

for (var tIndex = 0; tIndex < test.length; tIndex += 3) {

2836

var recType = test[tIndex];

2837

if (!typeof recType == 'number' || recType < REC_TYPE_UNKNOWN || recType > REC_TYPE_LAST) {

2838

console.log("unknown rec type: " + recType);

2839

throw "stop execution";

2840

}

2841

// if (curType == recType && curType != REC_TYPE_ADD) {

2842

// continue;

2843

// }

2844

var inStepRange = step_limit == 0 || curStep < step_limit;

2845

curType = recType;

2846

if (recType == REC_TYPE_OP) {

hasOp = true;

continue;

}

if (recType == REC_TYPE_UNKNOWN) {

2851

// these types do not advance step

2852

continue;

2853

}

2854

var bumpStep = false;

2855

var records = test[tIndex + 2];

2856

var fragType = records[0];

2857

if (recType == REC_TYPE_ADD) {

2858

if (records.length != 2) {

2859

console.log("expect only two elements: " + records.length);

2860

throw "stop execution";

2861

}

2862

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) {

2874

secondPath = tIndex;

2875

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2876

if (recType == REC_TYPE_PATH2 && hasOp) {

2877

secondPath = tIndex;

2878

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2879

if (recType == REC_TYPE_ACTIVE) {

2880

++activeMax;

2881

if (!draw_active || !inStepRange) {

continue;

}

lastActive = tIndex;

++activeCount;

bumpStep = true;

}

if (recType == REC_TYPE_ACTIVE_OP) {

2889

++opMax;

2890

if (!draw_op || !inStepRange) {

continue;

}

lastOp = tIndex;

++opCount;

bumpStep = true;

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2897

if (recType == REC_TYPE_AFTERPART) {

2898

if (draw_angle != 3 || !inStepRange) {

continue;

}

lastAngle = tIndex;

++angleCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2905

if (recType == REC_TYPE_ANGLE) {

2906

++angleMax;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2907

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]

2914

if (recType == REC_TYPE_COINCIDENCE) {

2915

++coinMax;

2916

if (!draw_coincidence || !inStepRange) {

continue;

}

lastCoin = tIndex;

++coinCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2923

if (recType == REC_TYPE_SECT) {

2924

if (records.length != 2) {

2925

console.log("expect only two elements: " + records.length);

2926

throw "stop execution";

}

++sectMax;

var sectBump = 1;

switch (fragType) {

case INTERSECT_LINE:

case INTERSECT_QUAD_LINE:

2933

case INTERSECT_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2934

case INTERSECT_CONIC_LINE:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2935

case INTERSECT_CONIC_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2936

case INTERSECT_CONIC:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2937

case INTERSECT_SELF_CUBIC:

2938

case INTERSECT_CUBIC_LINE:

2939

case INTERSECT_CUBIC_QUAD:

2940

case INTERSECT_CUBIC:

2941

sectBump = 1;

2942

break;

2943

case INTERSECT_LINE_2:

2944

case INTERSECT_QUAD_LINE_2:

2945

case INTERSECT_QUAD_2:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2946

case INTERSECT_CONIC_LINE_2:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2947

case INTERSECT_CONIC_QUAD_2:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2948

case INTERSECT_CONIC_2:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2949

case INTERSECT_CUBIC_LINE_2:

2950

case INTERSECT_CUBIC_QUAD_2:

2951

case INTERSECT_CUBIC_2:

2952

sectBump = 2;

2953

break;

2954

case INTERSECT_LINE_NO:

2955

case INTERSECT_QUAD_LINE_NO:

2956

case INTERSECT_QUAD_NO:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2957

case INTERSECT_CONIC_LINE_NO:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2958

case INTERSECT_CONIC_QUAD_NO:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2959

case INTERSECT_CONIC_NO:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2960

case INTERSECT_SELF_CUBIC_NO:

2961

case INTERSECT_CUBIC_LINE_NO:

2962

case INTERSECT_CUBIC_QUAD_NO:

2963

case INTERSECT_CUBIC_NO:

2964

sectBump = 0;

2965

break;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

2966

case INTERSECT_CONIC_QUAD_3:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2967

case INTERSECT_CUBIC_LINE_3:

2968

case INTERSECT_CUBIC_QUAD_3:

2969

case INTERSECT_CUBIC_3:

2970

sectBump = 3;

2971

break;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

2972

case INTERSECT_CONIC_QUAD_4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2973

case INTERSECT_CUBIC_QUAD_4:

2974

case INTERSECT_CUBIC_4:

sectBump = 4;

break;

default:

console.log("missing case " + records.length);

2979

throw "stop execution";

2980

}

2981

sectMax2 += sectBump;

2982

if (draw_intersection <= 1 || !inStepRange) {

continue;

}

lastSect = tIndex;

sectCount += sectBump;

2987

bumpStep = true;

2988

}

2989

if (recType == REC_TYPE_SORT) {

2990

++sortMax;

2991

if (!draw_sort || !inStepRange) {

continue;

}

lastSort = tIndex;

++sortCount;

bumpStep = true;

}

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2998

if (recType == REC_TYPE_TOP) {

2999

++topMax;

3000

if (!draw_top || !inStepRange) {

continue;

}

lastTop = tIndex;

++topCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3007

if (recType == REC_TYPE_MARK) {

3008

++markMax;

3009

if (!draw_mark || !inStepRange) {

continue;

}

lastMark = tIndex;

++markCount;

bumpStep = true;

}

if (bumpStep) {

lastIndex = tIndex;

logStart = test[tIndex + 1];

3019

logRange = records.length / 2;

++curStep;

}

}

stepMax = (draw_add ? addMax : 0)

3024

+ (draw_active ? activeMax : 0)

reed

0dc4dd6

2015-03-24 13:55:33 -0700

[diff] [blame]

3025

+ (draw_angle ? angleMax : 0)

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3026

+ (draw_coincidence ? coinMax : 0)

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3027

+ (draw_op ? opMax : 0)

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3028

+ (draw_sort ? sortMax : 0)

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3029

+ (draw_top ? topMax : 0)

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3030

+ (draw_mark ? markMax : 0)

3031

+ (draw_intersection == 2 ? sectMax : draw_intersection == 3 ? sectMax2 : 0);

3032

if (stepMax == 0) {

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3033

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]

3038

drawnConics = [];

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3039

drawnCubics = [];

3040

focusXmin = focusYmin = Infinity;

3041

focusXmax = focusYmax = -Infinity;

3042

var pathIndex = 0;

3043

var opLetter = 'S';

3044

for (var tIndex = lastIndex; tIndex >= 0; tIndex -= 3) {

3045

var recType = test[tIndex];

3046

var records = test[tIndex + 2];

3047

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

3048

var fragType = records[recordIndex];

3049

if (!typeof fragType == 'number' || fragType < 1 || fragType > FRAG_TYPE_LAST) {

3050

console.log("unknown in range frag type: " + fragType);

3051

throw "stop execution";

3052

}

3053

var frags = records[recordIndex + 1];

3054

focus_enabled = false;

3055

switch (recType) {

3056

case REC_TYPE_COMPUTED:

3057

if (draw_computed == 0) {

continue;

}

ctx.lineWidth = 1;

ctx.strokeStyle = pathIndex == 0 ? "black" : "red";

3062

ctx.fillStyle = "blue";

3063

var drawThis = false;

3064

switch (fragType) {

3065

case PATH_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3066

if ((draw_computed & 0x9) == 1 || ((draw_computed & 8) != 0

3067

&& (draw_computed & 7) == pathIndex)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3068

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]

3073

case PATH_CONIC:

3074

if ((draw_computed & 0xA) == 2 || ((draw_computed & 8) != 0

3075

&& (draw_computed & 7) == pathIndex)) {

3076

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

3077

frags[4], frags[5], frags[6]);

3078

drawThis = true;

3079

}

3080

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3081

case PATH_CUBIC:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3082

if ((draw_computed & 0xC) == 4 || ((draw_computed & 8) != 0

3083

&& (draw_computed & 7) == pathIndex)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3084

drawCubic(frags[0], frags[1], frags[2], frags[3],

3085

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);

3098

throw "stop execution";

3099

}

3100

if (!drawThis || collect_bounds) {

3101

break;

3102

}

3103

drawCurveSpecials(test, frags, fragType);

3104

break;

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3105

case REC_TYPE_ALIGNED:

3106

if (draw_path < 4) {

3107

continue;

3108

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3109

case REC_TYPE_PATH:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3110

case REC_TYPE_PATH2:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3111

if (REC_TYPE_ALIGNED != recType && draw_path >= 4) {

3112

continue;

3113

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

if (!draw_path) {

continue;

}

var firstPath = tIndex < secondPath;

3118

if ((draw_path & (firstPath ? 1 : 2)) == 0) {

continue;

}

ctx.lineWidth = 1;

ctx.strokeStyle = firstPath ? "black" : "red";

3123

ctx.fillStyle = "blue";

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3124

var frags2 = [];

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3125

switch (fragType) {

3126

case PATH_LINE:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3127

for (var i = 0; i < 4; ++ i) { frags2[i] = frags[i + 1]; }

3128

drawLine(frags2[0], frags2[1], frags2[2], frags2[3]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3129

break;

3130

case PATH_QUAD:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3131

for (var i = 0; i < 6; ++ i) { frags2[i] = frags[i + 1]; }

3132

drawQuad(frags2[0], frags2[1], frags2[2], frags2[3],

3133

frags2[4], frags2[5]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3134

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3135

case PATH_CONIC:

3136

for (var i = 0; i < 7; ++ i) { frags2[i] = frags[i + 1]; }

3137

drawConicWithQuads(frags2[0], frags2[1], frags2[2], frags2[3],

3138

frags2[4], frags2[5], frags2[6]);

3139

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3140

case PATH_CUBIC:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3141

for (var i = 0; i < 8; ++ i) { frags2[i] = frags[i + 1]; }

3142

drawCubic(frags2[0], frags2[1], frags2[2], frags2[3],

3143

frags2[4], frags2[5], frags2[6], frags2[7]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3144

break;

3145

default:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3146

console.log("unknown " + recType + " frag type: " + fragType);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3147

throw "stop execution";

3148

}

3149

if (collect_bounds) {

3150

break;

3151

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3152

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;

3157

case OP_DIFFERENCE: opLetter = 'D'; break;

3158

case OP_UNION: opLetter = 'U'; break;

3159

case OP_XOR: opLetter = 'X'; break;

3160

default:

3161

console.log("unknown REC_TYPE_OP frag type: " + fragType);

3162

throw "stop execution";

3163

}

3164

break;

3165

case REC_TYPE_ACTIVE:

3166

if (!draw_active || (step_limit > 0 && tIndex < lastActive)) {

3167

continue;

3168

}

3169

var x1 = frags[SPAN_X1];

3170

var y1 = frags[SPAN_Y1];

3171

var x2 = frags[SPAN_X2];

3172

var y2 = frags[SPAN_Y2];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3173

var x3, y3, x3, y4, w;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3174

ctx.lineWidth = 3;

3175

ctx.strokeStyle = "rgba(0,0,255, 0.3)";

3176

focus_enabled = true;

3177

switch (fragType) {

3178

case ACTIVE_LINE_SPAN:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3179

drawLine(x1, y1, x2, y2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3180

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3181

drawLineID(frags[0], x1, y1, x2, y2);

3182

}

3183

if (pt_labels) {

3184

var curve = [x1, y1, x2, y2];

3185

ctx.fillStyle = "blue";

3186

drawPoints(curve, PATH_LINE, pt_labels == 2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3187

}

3188

break;

3189

case ACTIVE_QUAD_SPAN:

3190

x3 = frags[SPAN_X3];

3191

y3 = frags[SPAN_Y3];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3192

drawQuad(x1, y1, x2, y2, x3, y3);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3193

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3194

drawQuadID(frags[0], x1, y1, x2, y2, x3, y3);

3195

}

3196

if (pt_labels) {

3197

var curve = [x1, y1, x2, y2, x3, y3];

3198

ctx.fillStyle = "blue";

3199

drawPoints(curve, PATH_QUAD, pt_labels == 2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3200

}

3201

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3202

case ACTIVE_CONIC_SPAN:

3203

x3 = frags[SPAN_X3];

3204

y3 = frags[SPAN_Y3];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3205

w = frags[SPAN_K_W];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3206

drawConicWithQuads(x1, y1, x2, y2, x3, y3, w);

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3207

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3208

drawConicID(frags[0], x1, y1, x2, y2, x3, y3, w);

3209

}

3210

if (pt_labels) {

3211

var curve = [x1, y1, x2, y2, x3, y3, w];

3212

ctx.fillStyle = "blue";

3213

drawPoints(curve, PATH_CONIC, pt_labels == 2);

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3214

}

3215

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3216

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]

3221

drawCubic(x1, y1, x2, y2, x3, y3, x4, y4);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3222

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3223

drawCubicID(frags[0], x1, y1, x2, y2, x3, y3, x4, y4);

3224

}

3225

if (pt_labels) {

3226

var curve = [x1, y1, x2, y2, x3, y3, x4, y4];

3227

ctx.fillStyle = "blue";

3228

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);

3233

throw "stop execution";

3234

}

3235

break;

3236

case REC_TYPE_ACTIVE_OP:

3237

if (!draw_op || (step_limit > 0 && tIndex < lastOp)) {

3238

continue;

3239

}

3240

focus_enabled = true;

3241

ctx.lineWidth = 3;

3242

var activeSpan = frags[7] == "1";

3243

ctx.strokeStyle = activeSpan ? "rgba(45,160,0, 0.3)" : "rgba(255,45,0, 0.5)";

3244

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

3245

drawCurve(curve);

3246

if (draw_op > 1) {

3247

drawArc(curve, false, frags[3], frags[4]);

3248

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)"

3257

: closeCount == 1 ? "rgba(0,127,0, 0.3)"

3258

: closeCount == 2 ? "rgba(0,127,127, 0.3)"

3259

: closeCount == 3 ? "rgba(127,127,0, 0.3)"

3260

: "rgba(127,0,127, 0.3)";

3261

focus_enabled = true;

switch (fragType) {

case ADD_MOVETO:

break;

case ADD_LINETO:

if (step_limit == 0 || tIndex >= lastAdd) {

3267

drawLine(frags[0], frags[1], frags[2], frags[3]);

}

break;

case ADD_QUADTO:

if (step_limit == 0 || tIndex >= lastAdd) {

3272

drawQuad(frags[0], frags[1], frags[2], frags[3], frags[4], frags[5]);

3273

}

3274

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3275

case ADD_CONICTO:

3276

if (step_limit == 0 || tIndex >= lastAdd) {

3277

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

3278

frags[4], frags[5], frags[6]);

3279

}

3280

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3281

case ADD_CUBICTO:

3282

if (step_limit == 0 || tIndex >= lastAdd) {

3283

drawCubic(frags[0], frags[1], frags[2], frags[3],

3284

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);

3294

throw "stop execution";

3295

}

3296

break;

3297

case REC_TYPE_ANGLE:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3298

angleBetween = frags[18] == "T";

3299

afterIndex = 0;

3300

if (draw_angle == 0 || draw_angle == 3 || (step_limit > 0 && tIndex < lastAngle)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3301

continue;

3302

}

3303

focus_enabled = true;

3304

ctx.lineWidth = 3;

3305

ctx.strokeStyle = "rgba(127,45,127, 0.3)";

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3306

var leftCurve = curvePartialByID(test, frags[0], frags[4], frags[5]);

3307

var midCurve = curvePartialByID(test, frags[6], frags[10], frags[11]);

3308

var rightCurve = curvePartialByID(test, frags[12], frags[16], frags[17]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3309

drawCurve(leftCurve);

3310

drawCurve(rightCurve);

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3311

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]

3312

drawCurve(midCurve);

3313

if (draw_angle > 1) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3314

drawVisibleOrder(leftCurve, 'L');

3315

drawVisibleOrder(rightCurve, 'R');

3316

}

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3317

if (draw_id) {

3318

drawVisibleID(leftCurve, 0.5, frags[0]);

3319

drawVisibleID(midCurve, 0.5, frags[6]);

3320

drawVisibleID(rightCurve, 0.5, frags[12]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3321

}

3322

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3323

case REC_TYPE_AFTERPART:

3324

if (draw_angle != 3 || (step_limit > 0 && tIndex < lastAngle)) {

3325

continue;

3326

}

3327

ctx.strokeStyle = afterIndex == 0 ? "rgba(255,0,0, 1.0)"

3328

: (afterIndex == 1) == angleBetween ? "rgba(0,128,0, 1.0)"

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3329

: "rgba(0,0,255, 1.0)";

3330

var curve;

3331

var id;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3332

switch (fragType) {

3333

case PATH_LINE:

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3334

curve = [ frags[0], frags[1], frags[2], frags[3] ];

3335

id = frags[4];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3336

break;

3337

case PATH_QUAD:

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3338

curve = [ frags[0], frags[1], frags[2], frags[3],

3339

frags[4], frags[5] ];

3340

id = frags[6];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3341

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3342

case PATH_CONIC:

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3343

curve = [ frags[0], frags[1], frags[2], frags[3],

3344

frags[4], frags[5], frags[6] ];

3345

id = frags[7];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3346

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3347

case PATH_CUBIC:

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3348

curve = [ frags[0], frags[1], frags[2], frags[3],

3349

frags[4], frags[5], frags[6], frags[7] ];

3350

id = frags[8];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3351

break;

3352

default:

3353

console.log("unknown REC_TYPE_AFTERPART frag type: " + fragType);

3354

throw "stop execution";

3355

}

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3356

drawCurve(curve);

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3357

if (draw_id) {

3358

drawVisibleID(curve, 0.5, id);

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3359

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3360

++afterIndex;

3361

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3362

case REC_TYPE_COINCIDENCE:

3363

if (!draw_coincidence || (step_limit > 0 && tIndex < lastCoin)) {

3364

continue;

3365

}

3366

focus_enabled = true;

3367

ctx.lineWidth = 3;

3368

ctx.strokeStyle = "rgba(127,45,63, 0.3)";

3369

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

3370

drawCurve(curve);

3371

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3372

case REC_TYPE_SECT:

3373

if (!draw_intersection) {

3374

continue;

3375

}

3376

if (draw_intersection != 1 && (step_limit > 0 && tIndex < lastSect)) {

3377

continue;

3378

}

3379

// draw_intersection == 1 : show all

3380

// draw_intersection == 2 : step == 0 ? show all : show intersection line #step

3381

// draw_intersection == 3 : step == 0 ? show all : show intersection #step

3382

ctx.lineWidth = 1;

3383

ctx.strokeStyle = "rgba(0,0,255, 0.3)";

3384

ctx.fillStyle = "blue";

3385

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;

3395

break;

3396

case INTERSECT_LINE_2:

3397

f.push(5, 6, 0, 10);

3398

f.push(8, 9, 7, 15);

3399

c1s = 1; c1l = 4; c2s = 11; c2l = 4;

3400

break;

3401

case INTERSECT_LINE_NO:

3402

c1s = 0; c1l = 4; c2s = 4; c2l = 4;

3403

break;

3404

case INTERSECT_QUAD_LINE:

3405

f.push(7, 8, 0, 9);

3406

c1s = 1; c1l = 6; c2s = 10; c2l = 4;

3407

break;

3408

case INTERSECT_QUAD_LINE_2:

3409

f.push(7, 8, 0, 12);

3410

f.push(10, 11, 9, 17);

3411

c1s = 1; c1l = 6; c2s = 13; c2l = 4;

3412

break;

3413

case INTERSECT_QUAD_LINE_NO:

3414

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;

3419

break;

3420

case INTERSECT_QUAD_2:

3421

f.push(7, 8, 0, 12);

3422

f.push(10, 11, 9, 19);

3423

c1s = 1; c1l = 6; c2s = 13; c2l = 6;

3424

break;

3425

case INTERSECT_QUAD_NO:

3426

c1s = 0; c1l = 6; c2s = 6; c2l = 6;

3427

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3428

case INTERSECT_CONIC_LINE:

3429

f.push(8, 9, 0, 10);

3430

c1s = 1; c1l = 7; c2s = 11; c2l = 4;

3431

break;

3432

case INTERSECT_CONIC_LINE_2:

3433

f.push(8, 9, 0, 12);

3434

f.push(11, 12, 10, 18);

3435

c1s = 1; c1l = 7; c2s = 14; c2l = 4;

3436

break;

3437

case INTERSECT_CONIC_LINE_NO:

3438

c1s = 0; c1l = 7; c2s = 7; c2l = 4;

3439

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3440

case INTERSECT_CONIC_QUAD:

3441

f.push(8, 9, 0, 10);

3442

c1s = 1; c1l = 7; c2s = 11; c2l = 6;

3443

break;

3444

case INTERSECT_CONIC_QUAD_2:

3445

f.push(8, 9, 0, 12);

3446

f.push(11, 12, 10, 18);

3447

c1s = 1; c1l = 7; c2s = 14; c2l = 6;

3448

break;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

3449

case INTERSECT_CONIC_QUAD_3:

3450

f.push(8, 9, 0, 15);

3451

f.push(11, 12, 10, 21);

3452

f.push(14, 15, 13, 22);

3453

c1s = 1; c1l = 7; c2s = 17; c2l = 6;

3454

break;

3455

case INTERSECT_CONIC_QUAD_4:

3456

f.push(8, 9, 0, 18);

3457

f.push(11, 12, 10, 24);

3458

f.push(14, 15, 13, 25);

3459

f.push(17, 18, 16, 26);

3460

c1s = 1; c1l = 7; c2s = 20; c2l = 6;

3461

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3462

case INTERSECT_CONIC_QUAD_NO:

3463

c1s = 0; c1l = 7; c2s = 7; c2l = 6;

3464

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3465

case INTERSECT_CONIC:

3466

f.push(8, 9, 0, 10);

3467

c1s = 1; c1l = 7; c2s = 11; c2l = 7;

3468

break;

3469

case INTERSECT_CONIC_2:

3470

f.push(8, 9, 0, 13);

3471

f.push(11, 12, 10, 21);

3472

c1s = 1; c1l = 7; c2s = 14; c2l = 7;

3473

break;

3474

case INTERSECT_CONIC_NO:

3475

c1s = 0; c1l = 7; c2s = 7; c2l = 7;

3476

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3477

case INTERSECT_SELF_CUBIC:

3478

f.push(9, 10, 0, 11);

3479

c1s = 1; c1l = 8; c2s = 0; c2l = 0;

3480

break;

3481

case INTERSECT_SELF_CUBIC_NO:

3482

c1s = 0; c1l = 8; c2s = 0; c2l = 0;

3483

break;

3484

case INTERSECT_CUBIC_LINE:

3485

f.push(9, 10, 0, 11);

3486

c1s = 1; c1l = 8; c2s = 12; c2l = 4;

3487

break;

3488

case INTERSECT_CUBIC_LINE_2:

3489

f.push(9, 10, 0, 14);

3490

f.push(12, 13, 11, 19);

3491

c1s = 1; c1l = 8; c2s = 15; c2l = 4;

3492

break;

3493

case INTERSECT_CUBIC_LINE_3:

3494

f.push(9, 10, 0, 17);

3495

f.push(12, 13, 11, 22);

3496

f.push(15, 16, 14, 23);

3497

c1s = 1; c1l = 8; c2s = 18; c2l = 4;

3498

break;

3499

case INTERSECT_CUBIC_QUAD_NO:

3500

c1s = 0; c1l = 8; c2s = 8; c2l = 6;

3501

break;

3502

case INTERSECT_CUBIC_QUAD:

3503

f.push(9, 10, 0, 11);

3504

c1s = 1; c1l = 8; c2s = 12; c2l = 6;

3505

break;

3506

case INTERSECT_CUBIC_QUAD_2:

3507

f.push(9, 10, 0, 14);

3508

f.push(12, 13, 11, 21);

3509

c1s = 1; c1l = 8; c2s = 15; c2l = 6;

3510

break;

3511

case INTERSECT_CUBIC_QUAD_3:

3512

f.push(9, 10, 0, 17);

3513

f.push(12, 13, 11, 24);

3514

f.push(15, 16, 14, 25);

3515

c1s = 1; c1l = 8; c2s = 18; c2l = 6;

3516

break;

3517

case INTERSECT_CUBIC_QUAD_4:

3518

f.push(9, 10, 0, 20);

3519

f.push(12, 13, 11, 27);

3520

f.push(15, 16, 14, 28);

3521

f.push(18, 19, 17, 29);

3522

c1s = 1; c1l = 8; c2s = 21; c2l = 6;

3523

break;

3524

case INTERSECT_CUBIC_LINE_NO:

3525

c1s = 0; c1l = 8; c2s = 8; c2l = 4;

3526

break;

3527

case INTERSECT_CUBIC:

3528

f.push(9, 10, 0, 11);

3529

c1s = 1; c1l = 8; c2s = 12; c2l = 8;

3530

break;

3531

case INTERSECT_CUBIC_2:

3532

f.push(9, 10, 0, 14);

3533

f.push(12, 13, 11, 23);

3534

c1s = 1; c1l = 8; c2s = 15; c2l = 8;

3535

break;

3536

case INTERSECT_CUBIC_3:

3537

f.push(9, 10, 0, 17);

3538

f.push(12, 13, 11, 26);

3539

f.push(15, 16, 14, 27);

3540

c1s = 1; c1l = 8; c2s = 18; c2l = 8;

3541

break;

3542

case INTERSECT_CUBIC_4:

3543

f.push(9, 10, 0, 20);

3544

f.push(12, 13, 11, 29);

3545

f.push(15, 16, 14, 30);

3546

f.push(18, 19, 17, 31);

3547

c1s = 1; c1l = 8; c2s = 21; c2l = 8;

3548

break;

3549

case INTERSECT_CUBIC_NO:

3550

c1s = 0; c1l = 8; c2s = 8; c2l = 8;

3551

break;

3552

default:

3553

console.log("unknown REC_TYPE_SECT frag type: " + fragType);

3554

throw "stop execution";

3555

}

3556

if (draw_intersection != 1) {

3557

var id = -1;

3558

var curve;

3559

switch (c1l) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3560

case 4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3561

drawLine(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3]);

3562

if (draw_id) {

3563

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3]];

3564

id = idByCurve(test, curve, PATH_LINE);

}

break;

case 6:

drawQuad(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3569

frags[c1s + 4], frags[c1s + 5]);

3570

if (draw_id) {

3571

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3572

frags[c1s + 4], frags[c1s + 5]];

3573

id = idByCurve(test, curve, PATH_QUAD);

3574

}

3575

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3576

case 7:

3577

drawConicWithQuads(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3578

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6]);

3579

if (draw_id) {

3580

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3581

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6]];

3582

id = idByCurve(test, curve, PATH_CONIC);

3583

}

3584

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3585

case 8:

3586

drawCubic(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3587

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6], frags[c1s + 7]);

3588

if (draw_id) {

3589

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3590

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6], frags[c1s + 7]];

3591

id = idByCurve(test, curve, PATH_CUBIC);

}

break;

}

if (id >= 0) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3596

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]

3602

case 4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3603

drawLine(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3]);

3604

if (draw_id) {

3605

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3]];

3606

id = idByCurve(test, curve, PATH_LINE);

}

break;

case 6:

drawQuad(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3611

frags[c2s + 4], frags[c2s + 5]);

3612

if (draw_id) {

3613

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3614

frags[c2s + 4], frags[c2s + 5]];

3615

id = idByCurve(test, curve, PATH_QUAD);

3616

}

3617

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3618

case 7:

3619

drawConicWithQuads(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3620

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6]);

3621

if (draw_id) {

3622

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3623

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6]];

3624

id = idByCurve(test, curve, PATH_CONIC);

3625

}

3626

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3627

case 8:

3628

drawCubic(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3629

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6], frags[c2s + 7]);

3630

if (draw_id) {

3631

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3632

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6], frags[c2s + 7]];

3633

id = idByCurve(test, curve, PATH_CUBIC);

}

break;

}

if (id >= 0) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3638

drawVisibleID(curve, 0.5, id);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3639

}

3640

}

3641

if (collect_bounds) {

3642

break;

3643

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3644

if (draw_intersection != 3 || step_limit == 0 || tIndex >= lastSect) {

3645

for (var idx = 0; idx < f.length; idx += 4) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3646

drawPoint(frags[f[idx]], frags[f[idx + 1]], true);

3647

}

3648

}

3649

if (!draw_intersectT) {

3650

break;

3651

}

3652

ctx.fillStyle = "red";

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3653

if (draw_intersection != 3 || step_limit == 0 || tIndex >= lastSect) {

3654

for (var idx = 0; idx < f.length; idx += 4) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3655

drawTAtPointUp(frags[f[idx]], frags[f[idx + 1]], frags[f[idx + 2]]);

3656

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)";

3666

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);

3675

throw "stop execution";

3676

}

3677

break;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3678

case REC_TYPE_TOP:

3679

if (!draw_top || (step_limit > 0 && tIndex < lastTop)) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = "rgba(127,127,0, 0.5)";

3684

focus_enabled = true;

3685

{

3686

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

3687

drawCurve(curve);

3688

var type = PATH_LINE + (curve.length / 2 - 2);

3689

var mid = pointAtT(curve, type, 0.5);

3690

var d = dxy_at_t(curve, type, 0.5);

3691

drawArrow(mid.x, mid.y, d.x, d.y, 0.3);

3692

}

3693

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3694

case REC_TYPE_MARK:

3695

if (!draw_mark || (step_limit > 0 && tIndex < lastMark)) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = fragType >= MARK_DONE_LINE ?

3700

"rgba(127,0,127, 0.5)" : "rgba(127,127,0, 0.5)";

3701

focus_enabled = true;

switch (fragType) {

case MARK_LINE:

case MARK_DONE_LINE:

case MARK_UNSORTABLE_LINE:

3706

case MARK_SIMPLE_LINE:

3707

case MARK_SIMPLE_DONE_LINE:

3708

case MARK_DONE_UNARY_LINE:

3709

drawLinePartial(frags[1], frags[2], frags[3], frags[4],

3710

frags[5], frags[9]);

3711

if (draw_id) {

3712

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:

3719

case MARK_SIMPLE_QUAD:

3720

case MARK_SIMPLE_DONE_QUAD:

3721

case MARK_DONE_UNARY_QUAD:

3722

drawQuadPartial(frags[1], frags[2], frags[3], frags[4],

3723

frags[5], frags[6], frags[7], frags[11]);

3724

if (draw_id) {

3725

drawQuadPartialID(frags[0], frags[1], frags[2], frags[3], frags[4],

3726

frags[5], frags[6], frags[7], frags[11]);

}

break;

case MARK_CUBIC:

case MARK_DONE_CUBIC:

3731

case MARK_UNSORTABLE_CUBIC:

3732

case MARK_SIMPLE_CUBIC:

3733

case MARK_SIMPLE_DONE_CUBIC:

3734

case MARK_DONE_UNARY_CUBIC:

3735

drawCubicPartial(frags[1], frags[2], frags[3], frags[4],

3736

frags[5], frags[6], frags[7], frags[8], frags[9], frags[13]);

3737

if (draw_id) {

3738

drawCubicPartialID(frags[0], frags[1], frags[2], frags[3], frags[4],

3739

frags[5], frags[6], frags[7], frags[8], frags[9], frags[13]);

3740

}

3741

break;

3742

case MARK_ANGLE_LAST:

3743

// FIXME: ignored for now

3744

break;

3745

default:

3746

console.log("unknown REC_TYPE_MARK frag type: " + fragType);

3747

throw "stop execution";

}

break;

default:

continue;

}

}

switch (recType) {

case REC_TYPE_SORT:

if (!draw_sort || (step_limit > 0 && tIndex < lastSort)) {

3757

break;

3758

}

3759

var angles = []; // use tangent lines to describe arcs

var windFrom = [];

var windTo = [];

var opp = [];

var minXY = Number.MAX_VALUE;

3764

var partial;

3765

focus_enabled = true;

3766

var someUnsortable = false;

3767

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

3768

var fragType = records[recordIndex];

3769

var frags = records[recordIndex + 1];

3770

var unsortable = (fragType == SORT_UNARY && frags[14]) ||

3771

(fragType == SORT_BINARY && frags[16]);

3772

someUnsortable |= unsortable;

switch (fragType) {

case SORT_UNARY:

case SORT_BINARY:

partial = curvePartialByID(test, frags[0], frags[6], frags[8]);

3777

break;

3778

default:

3779

console.log("unknown REC_TYPE_SORT frag type: " + fragType);

3780

throw "stop execution";

3781

}

3782

var dx = boundsWidth(partial);

3783

var dy = boundsHeight(partial);

3784

minXY = Math.min(minXY, dx * dx + dy * dy);

3785

if (collect_bounds) {

3786

continue;

3787

}

3788

angles.push(tangent(partial));

3789

var from = frags[12];

var to = frags[12];

var sgn = frags[10];

if (sgn < 0) {

from -= frags[11];

} else if (sgn > 0) {

3795

to -= frags[11];

3796

}

3797

windFrom.push(from + (unsortable ? "!" : ""));

3798

windTo.push(to + (unsortable ? "!" : ""));

3799

opp.push(fragType == SORT_BINARY);

3800

if (draw_sort == 1) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3801

drawVisibleOrder(partial, frags[12]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3802

} else {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3803

drawVisibleOrder(partial, (recordIndex / 2) + 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3804

}

3805

}

3806

var radius = Math.sqrt(minXY) / 2 * scale;

3807

radius = Math.min(50, radius);

3808

var scaledRadius = radius / scale;

3809

var centerX = partial[0];

3810

var centerY = partial[1];

3811

if (collect_bounds) {

3812

if (focus_enabled) {

3813

focusXmin = Math.min(focusXmin, centerX - scaledRadius);

3814

focusYmin = Math.min(focusYmin, centerY - scaledRadius);

3815

focusXmax = Math.max(focusXmax, centerX + scaledRadius);

3816

focusYmax = Math.max(focusYmax, centerY + scaledRadius);

}

break;

}

break;

default:

break;

}

}

if (collect_bounds) {

3826

return;

3827

}

3828

if (draw_log && logStart >= 0) {

3829

ctx.font = "normal 10px Arial";

3830

ctx.textAlign = "left";

3831

ctx.beginPath();

3832

var top = screenHeight - 20 - (logRange + 2) * 10;

3833

ctx.rect(50, top, screenWidth - 100, (logRange + 2) * 10);

3834

ctx.fillStyle = "white";

3835

ctx.fill();

3836

ctx.fillStyle = "rgba(0,0,0, 0.5)";

3837

if (logStart > 0) {

3838

ctx.fillText(lines[logStart - 1], 50, top + 8);

3839

}

3840

ctx.fillStyle = "black";

3841

for (var idx = 0; idx < logRange; ++idx) {

3842

ctx.fillText(lines[logStart + idx], 50, top + 18 + 10 * idx);

3843

}

3844

ctx.fillStyle = "rgba(0,0,0, 0.5)";

3845

if (logStart + logRange < lines.length) {

3846

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]

3851

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3852

// drawBox(pos++, "yellow", "black", opLetter, true, '');

3853

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_intersection > 1 ? sectCount : sectMax2, draw_intersection, intersectionKey);

3854

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_add ? addCount : addMax, draw_add, addKey);

3855

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_active ? activeCount : activeMax, draw_active, activeKey);

3856

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]

3857

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]

3858

drawBox(pos++, "rgba(127,127,0, 0.3)", "black", draw_op ? opCount : opMax, draw_op, opKey);

3859

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]

3860

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]

3861

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]

3862

drawBox(pos++, "black", "white",

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3863

(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]

3864

drawBox(pos++, "rgba(0,63,0, 0.7)", "white",

3865

(new Array('Q', 'Q', 'C', 'QC', 'Qc', 'Cq'))[draw_computed],

3866

draw_computed != 0, computedKey);

3867

drawBox(pos++, "green", "black", step_limit, drawSomething, '');

3868

drawBox(pos++, "green", "black", stepMax, drawSomething, '');

3869

drawBox(pos++, "rgba(255,0,0, 0.6)", "black", lastIndex, drawSomething & draw_log, '');

3870

drawBox(pos++, "rgba(255,0,0, 0.6)", "black", test.length - 1, drawSomething & draw_log, '');

if (curve_t) {

drawCurveTControl();

}

ctx.font = "normal 20px Arial";

3875

ctx.fillStyle = "rgba(0,0,0, 0.3)";

3876

ctx.textAlign = "right";

3877

ctx.fillText(scale.toFixed(decimal_places) + 'x' , screenWidth - 10, screenHeight - 5);

3878

}

3879

if (draw_hints) {

3880

ctx.font = "normal 10px Arial";

3881

ctx.fillStyle = "rgba(0,0,0, 0.5)";

3882

ctx.textAlign = "right";

3883

var y = 4;

3884

ctx.fillText("control lines : " + controlLinesKey, ctx.screenWidthwidth - 10, pos * 50 + y++ * 10);

3885

ctx.fillText("curve t : " + curveTKey, screenWidth - 10, pos * 50 + y++ * 10);

3886

ctx.fillText("deriviatives : " + deriviativesKey, screenWidth - 10, pos * 50 + y++ * 10);

3887

ctx.fillText("intersect t : " + intersectTKey, screenWidth - 10, pos * 50 + y++ * 10);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3888

ctx.fillText("log : " + logKey, screenWidth - 10, pos * 50 + y++ * 10);

3889

ctx.fillText("log curve : " + logCurvesKey, screenWidth - 10, pos * 50 + y++ * 10);

3890

ctx.fillText("mid point : " + midpointKey, screenWidth - 10, pos * 50 + y++ * 10);

3891

ctx.fillText("points : " + ptsKey, screenWidth - 10, pos * 50 + y++ * 10);

3892

ctx.fillText("sequence : " + sequenceKey, screenWidth - 10, pos * 50 + y++ * 10);

3893

ctx.fillText("xy : " + xyKey, screenWidth - 10, pos * 50 + y++ * 10);

}

}

function drawBox(y, backC, foreC, str, enable, label) {

3898

ctx.beginPath();

3899

ctx.fillStyle = backC;

3900

ctx.rect(screenWidth - 40, y * 50 + 10, 40, 30);

3901

ctx.fill();

3902

ctx.font = "normal 16px Arial";

3903

ctx.fillStyle = foreC;

3904

ctx.textAlign = "center";

3905

ctx.fillText(str, screenWidth - 20, y * 50 + 32);

3906

if (!enable) {

3907

ctx.fillStyle = "rgba(255,255,255, 0.5)";

ctx.fill();

}

if (label != '') {

ctx.font = "normal 9px Arial";

3912

ctx.fillStyle = "black";

3913

ctx.fillText(label, screenWidth - 47, y * 50 + 40);

}

}

function drawCurveTControl() {

3918

ctx.lineWidth = 2;

3919

ctx.strokeStyle = "rgba(0,0,0, 0.3)";

3920

ctx.beginPath();

3921

ctx.rect(screenWidth - 80, 40, 28, screenHeight - 80);

3922

ctx.stroke();

3923

var ty = 40 + curveT * (screenHeight - 80);

3924

ctx.beginPath();

3925

ctx.moveTo(screenWidth - 80, ty);

3926

ctx.lineTo(screenWidth - 85, ty - 5);

3927

ctx.lineTo(screenWidth - 85, ty + 5);

3928

ctx.lineTo(screenWidth - 80, ty);

3929

ctx.fillStyle = "rgba(0,0,0, 0.6)";

3930

ctx.fill();

3931

var num = curveT.toFixed(decimal_places);

3932

ctx.font = "normal 10px Arial";

3933

ctx.textAlign = "left";

3934

ctx.fillText(num, screenWidth - 78, ty);

3935

}

3936

3937

function ptInTControl() {

3938

var e = window.event;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3939

var tgt = e.target || e.srcElement;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3940

var left = tgt.offsetLeft;

3941

var top = tgt.offsetTop;

3942

var x = (e.clientX - left);

3943

var y = (e.clientY - top);

3944

if (x < screenWidth - 80 || x > screenWidth - 50) {

3945

return false;

3946

}

3947

if (y < 40 || y > screenHeight - 80) {

3948

return false;

3949

}

3950

curveT = (y - 40) / (screenHeight - 120);

3951

if (curveT < 0 || curveT > 1) {

3952

throw "stop execution";

}

return true;

}

function drawTop() {

if (tests[testIndex] == null) {

3959

var str = testDivs[testIndex].textContent;

3960

parse_all(str);

3961

var title = testDivs[testIndex].id.toString();

3962

testTitles[testIndex] = title;

3963

}

3964

init(tests[testIndex]);

redraw();

}

function redraw() {

if (focus_on_selection) {

3970

collect_bounds = true;

3971

draw(tests[testIndex], testLines[testIndex], testTitles[testIndex]);

3972

collect_bounds = false;

3973

if (focusXmin < focusXmax && focusYmin < focusYmax) {

3974

setScale(focusXmin, focusXmax, focusYmin, focusYmax);

}

}

ctx.beginPath();

ctx.fillStyle = "white";

3979

ctx.rect(0, 0, screenWidth, screenHeight);

3980

ctx.fill();

3981

draw(tests[testIndex], testLines[testIndex], testTitles[testIndex]);

3982

}

3983

3984

function dumpCurvePartial(test, id, t0, t1) {

3985

var curve = curveByID(test, id);

3986

var name = ["line", "quad", "cubic"][curve.length / 2 - 2];

3987

console.log("id=" + id + " " + name + "=" + curveToString(curve)

3988

+ " t0=" + t0 + " t1=" + t1

3989

+ " partial=" + curveToString(curvePartialByID(test, id, t0, t1)));

3990

}

3991

3992

function dumpAngleTest(test, id, t0, t1) {

3993

var curve = curveByID(test, id);

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3994

console.log(" { {" + curveToString(curve) + "}, "

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3995

+ curve.length / 2 + ", " + t0 + ", " + t1 + ", {} }, //");

3996

}

3997

3998

function dumpLogToConsole() {

if (logStart < 0) {

return;

}

var test = tests[testIndex];

4003

var recType = REC_TYPE_UNKNOWN;

4004

var records;

4005

for (var index = 0; index < test.length; index += 3) {

4006

var lastLineNo = test[index + 1];

4007

if (lastLineNo >= logStart && lastLineNo < logStart + logRange) {

4008

recType = test[index];

4009

records = test[index + 2];

break;

}

}

if (recType == REC_TYPE_UNKNOWN) {

4014

return;

4015

}

4016

var lines = testLines[testIndex];

4017

for (var idx = 0; idx < logRange; ++idx) {

4018

var line = lines[logStart + idx];

4019

console.log(line);

4020

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

4021

var fragType = records[recordIndex];

4022

var frags = records[recordIndex + 1];

4023

if (recType == REC_TYPE_ANGLE && fragType == ANGLE_AFTER) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4024

dumpCurvePartial(test, frags[0], frags[4], frags[5]);

4025

dumpCurvePartial(test, frags[6], frags[10], frags[11]);

4026

dumpCurvePartial(test, frags[12], frags[16], frags[17]);

4027

console.log("\nstatic IntersectData intersectDataSet[] = { //");

4028

dumpAngleTest(test, frags[0], frags[4], frags[5]);

4029

dumpAngleTest(test, frags[6], frags[10], frags[11]);

4030

dumpAngleTest(test, frags[12], frags[16], frags[17]);

4031

console.log("}; //");

}

}

}

}

var activeKey = 'a';

var pathKey = 'b';

var pathBackKey = 'B';

4040

var centerKey = 'c';

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

4041

var coincidenceKey = 'C';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4042

var addKey = 'd';

4043

var deriviativesKey = 'f';

4044

var angleKey = 'g';

4045

var angleBackKey = 'G';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4046

var intersectionKey = 'i';

4047

var intersectionBackKey = 'I';

4048

var sequenceKey = 'j';

4049

var midpointKey = 'k';

4050

var logKey = 'l';

4051

var logToConsoleKey = 'L';

var markKey = 'm';

var sortKey = 'o';

var opKey = 'p';

var opBackKey = 'P';

var computedKey = 'q';

4057

var computedBackKey = 'Q';

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4058

var directionKey = 'r';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4059

var stepKey = 's';

4060

var stepBackKey = 'S';

4061

var intersectTKey = 't';

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

4062

var topKey = 'T';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4063

var curveTKey = 'u';

4064

var controlLinesBackKey = 'V';

4065

var controlLinesKey = 'v';

4066

var ptsKey = 'x';

4067

var xyKey = 'y';

4068

var logCurvesKey = 'z';

4069

var focusKey = '`';

4070

var idKey = '.';

4071

var retinaKey = '\\';

4072

4073

function doKeyPress(evt) {

4074

var char = String.fromCharCode(evt.charCode);

4075

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]

4092

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4093

break;

4094

case addKey:

4095

draw_add ^= true;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4096

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4097

break;

4098

case angleKey:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4099

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]

4108

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4109

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

4110

case coincidenceKey:

4111

draw_coincidence ^= true;

4112

redraw();

4113

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4114

case controlLinesBackKey:

4115

control_lines = (control_lines + 3) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4116

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4117

break;

4118

case controlLinesKey:

4119

control_lines = (control_lines + 1) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4120

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4121

break;

4122

case computedBackKey:

4123

draw_computed = (draw_computed + 5) % 6;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4124

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4125

break;

4126

case computedKey:

4127

draw_computed = (draw_computed + 1) % 6;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4128

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:

4138

draw_deriviatives = (draw_deriviatives + 1) % 3;

4139

redraw();

4140

break;

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4141

case directionKey:

4142

draw_direction ^= true;

4143

redraw();

4144

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4145

case focusKey:

4146

focus_on_selection ^= true;

4147

setScale(xmin, xmax, ymin, ymax);

4148

redraw();

4149

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

case idKey:

draw_id ^= true;

redraw();

break;

case intersectionBackKey:

4155

draw_intersection = (draw_intersection + 3) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4156

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4157

break;

4158

case intersectionKey:

4159

draw_intersection = (draw_intersection + 1) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4160

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4161

break;

4162

case intersectTKey:

4163

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;

4192

redraw();

4193

break;

4194

case pathKey:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

4195

draw_path = (draw_path + 1) % (4 + (hasAlignedPath ? 3 : 0));

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4196

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4197

break;

4198

case pathBackKey:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

4199

draw_path = (draw_path + 3 + (hasAlignedPath ? 3 : 0)) % (4 + (hasAlignedPath ? 3 : 0));

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4200

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4201

break;

4202

case ptsKey:

4203

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) {

4221

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]

4236

case xyKey:

4237

debug_xy = (debug_xy + 1) % 3;

redraw();

break;

case '-':

focusWasOn = focus_on_selection;

4242

if (focusWasOn) {

4243

focus_on_selection = false;

scale /= 1.2;

} else {

scale /= 2;

calcLeftTop();

}

redraw();

focus_on_selection = focusWasOn;

break;

case '=':

case '+':

focusWasOn = focus_on_selection;

4255

if (focusWasOn) {

4256

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) {

4280

var char = evt.keyCode;

4281

var preventDefault = false;

4282

switch (char) {

4283

case 37: // left arrow

if (evt.shiftKey) {

testIndex -= 9;

}

if (--testIndex < 0)

testIndex = tests.length - 1;

4289

drawTop();

4290

preventDefault = true;

4291

break;

4292

case 39: // right arrow

if (evt.shiftKey) {

testIndex += 9;

}

if (++testIndex >= tests.length)

4297

testIndex = 0;

4298

drawTop();

4299

preventDefault = true;

4300

break;

4301

}

4302

if (preventDefault) {

4303

evt.preventDefault();

return false;

}

return true;

}

(function() {

var hidden = "hidden";

4311

4312

// Standards:

4313

if (hidden in document)

4314

document.addEventListener("visibilitychange", onchange);

4315

else if ((hidden = "mozHidden") in document)

4316

document.addEventListener("mozvisibilitychange", onchange);

4317

else if ((hidden = "webkitHidden") in document)

4318

document.addEventListener("webkitvisibilitychange", onchange);

4319

else if ((hidden = "msHidden") in document)

4320

document.addEventListener("msvisibilitychange", onchange);

4321

// IE 9 and lower:

4322

else if ('onfocusin' in document)

4323

document.onfocusin = document.onfocusout = onchange;

4324

// All others:

4325

else

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4326

window.onpageshow = window.onpagehide

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4327

= window.onfocus = window.onblur = onchange;

4328

4329

function onchange (evt) {

4330

var v = 'visible', h = 'hidden',

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4331

evtMap = {

4332

focus:v, focusin:v, pageshow:v, blur:h, focusout:h, pagehide:h

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4333

};

4334

4335

evt = evt || window.event;

4336

if (evt.type in evtMap)

4337

document.body.className = evtMap[evt.type];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4338

else

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4339

document.body.className = this[hidden] ? "hidden" : "visible";

}

})();

function calcXY() {

var e = window.event;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4345

var tgt = e.target || e.srcElement;

caryclark