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

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

[diff] [blame]

1288

</div>

caryclark

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

[diff] [blame]

1289

caryclark

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

[diff] [blame]

</div>

caryclark

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

[diff] [blame]

1294

var testDivs = [

caryclark

34efb70

2016-10-24 08:19:06 -0700

[diff] [blame]

1295

simplifyTest_1,

caryclark

30b9fdd

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

[diff] [blame]

1296

];

caryclark

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

[diff] [blame]

1297

1298

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;

1307

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]

1312

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;

1317

var control_lines = 0;

1318

var curve_t = false;

1319

var debug_xy = 1;

1320

var focus_enabled = false;

1321

var focus_on_selection = false;

1322

var step_limit = 0;

1323

var draw_active = false;

1324

var draw_add = false;

1325

var draw_angle = 0;

caryclark

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

[diff] [blame]

1326

var draw_coincidence = false;

caryclark

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

[diff] [blame]

1327

var draw_deriviatives = 0;

1328

var draw_hints = false;

caryclark

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

[diff] [blame]

1329

var draw_id = false;

1330

var draw_intersection = 0;

1331

var draw_intersectT = false;

1332

var draw_legend = true;

1333

var draw_log = false;

1334

var draw_mark = false;

1335

var draw_midpoint = false;

1336

var draw_op = 0;

1337

var draw_sequence = false;

1338

var draw_sort = 0;

caryclark

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

[diff] [blame]

1339

var draw_top = false;

caryclark

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

[diff] [blame]

1340

var draw_path = 3;

1341

var draw_computed = 0;

1342

var retina_scale = !!window.devicePixelRatio;

var activeCount = 0;

var addCount = 0;

var angleCount = 0;

caryclark

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

[diff] [blame]

1347

var coinCount = 0;

caryclark

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

[diff] [blame]

1348

var opCount = 0;

1349

var sectCount = 0;

1350

var sortCount = 0;

caryclark

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

[diff] [blame]

1351

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]

1356

var coinMax = 0;

caryclark

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

[diff] [blame]

1357

var sectMax = 0;

1358

var sectMax2 = 0;

1359

var sortMax = 0;

caryclark

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

[diff] [blame]

1360

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]

1366

var hasAlignedPath = false;

caryclark

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

[diff] [blame]

1367

var hasComputedPath = false;

caryclark

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

[diff] [blame]

1368

var angleBetween = false;

1369

var afterIndex = 0;

caryclark

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

[diff] [blame]

1370

1371

var firstActiveSpan = -1;

var logStart = -1;

var logRange = 0;

var SPAN_ID = 0;

var SPAN_X1 = SPAN_ID + 1;

1377

var SPAN_Y1 = SPAN_X1 + 1;

1378

var SPAN_X2 = SPAN_Y1 + 1;

1379

var SPAN_Y2 = SPAN_X2 + 1;

caryclark

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

[diff] [blame]

1380

caryclark

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

[diff] [blame]

1381

var SPAN_L_TX = SPAN_Y2 + 1;

caryclark

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

[diff] [blame]

1382

var SPAN_L_TY = SPAN_L_TX + 1;

caryclark

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

[diff] [blame]

1383

var SPAN_L_OTHER = SPAN_L_TY + 1;

caryclark

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

[diff] [blame]

1384

var SPAN_L_OTHERT = SPAN_L_OTHER + 1;

1385

var SPAN_L_OTHERI = SPAN_L_OTHERT + 1;

1386

var SPAN_L_SUM = SPAN_L_OTHERI + 1;

1387

var SPAN_L_VAL = SPAN_L_SUM + 1;

1388

var SPAN_L_OPP = SPAN_L_VAL + 1;

1389

1390

var SPAN_X3 = SPAN_Y2 + 1;

1391

var SPAN_Y3 = SPAN_X3 + 1;

caryclark

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

[diff] [blame]

1392

caryclark

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

[diff] [blame]

1393

var SPAN_Q_TX = SPAN_Y3 + 1;

caryclark

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

[diff] [blame]

1394

var SPAN_Q_TY = SPAN_Q_TX + 1;

caryclark

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

[diff] [blame]

1395

var SPAN_Q_OTHER = SPAN_Q_TY + 1;

caryclark

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

[diff] [blame]

1396

var SPAN_Q_OTHERT = SPAN_Q_OTHER + 1;

1397

var SPAN_Q_OTHERI = SPAN_Q_OTHERT + 1;

1398

var SPAN_Q_SUM = SPAN_Q_OTHERI + 1;

1399

var SPAN_Q_VAL = SPAN_Q_SUM + 1;

1400

var SPAN_Q_OPP = SPAN_Q_VAL + 1;

1401

caryclark

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

[diff] [blame]

1402

var SPAN_K_W = SPAN_Y3 + 1;

caryclark

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

[diff] [blame]

1403

var SPAN_K_TX = SPAN_K_W + 1;

caryclark

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

[diff] [blame]

1404

var SPAN_K_TY = SPAN_K_TX + 1;

caryclark

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

[diff] [blame]

1405

var SPAN_K_OTHER = SPAN_K_TY + 1;

caryclark

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

[diff] [blame]

1406

var SPAN_K_OTHERT = SPAN_K_OTHER + 1;

1407

var SPAN_K_OTHERI = SPAN_K_OTHERT + 1;

1408

var SPAN_K_SUM = SPAN_K_OTHERI + 1;

1409

var SPAN_K_VAL = SPAN_K_SUM + 1;

1410

var SPAN_K_OPP = SPAN_K_VAL + 1;

1411

caryclark

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

[diff] [blame]

1412

var SPAN_X4 = SPAN_Y3 + 1;

1413

var SPAN_Y4 = SPAN_X4 + 1;

caryclark

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

[diff] [blame]

1414

caryclark

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

[diff] [blame]

1415

var SPAN_C_TX = SPAN_Y4 + 1;

caryclark

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

[diff] [blame]

1416

var SPAN_C_TY = SPAN_C_TX + 1;

caryclark

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

[diff] [blame]

1417

var SPAN_C_OTHER = SPAN_C_TY + 1;

caryclark

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

[diff] [blame]

1418

var SPAN_C_OTHERT = SPAN_C_OTHER + 1;

1419

var SPAN_C_OTHERI = SPAN_C_OTHERT + 1;

1420

var SPAN_C_SUM = SPAN_C_OTHERI + 1;

1421

var SPAN_C_VAL = SPAN_C_SUM + 1;

1422

var SPAN_C_OPP = SPAN_C_VAL + 1;

1423

1424

var ACTIVE_LINE_SPAN = 1;

1425

var ACTIVE_QUAD_SPAN = ACTIVE_LINE_SPAN + 1;

caryclark

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

[diff] [blame]

1426

var ACTIVE_CONIC_SPAN = ACTIVE_QUAD_SPAN + 1;

1427

var ACTIVE_CUBIC_SPAN = ACTIVE_CONIC_SPAN + 1;

caryclark

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

[diff] [blame]

1428

1429

var ADD_MOVETO = ACTIVE_CUBIC_SPAN + 1;

1430

var ADD_LINETO = ADD_MOVETO + 1;

1431

var ADD_QUADTO = ADD_LINETO + 1;

caryclark

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

[diff] [blame]

1432

var ADD_CONICTO = ADD_QUADTO + 1;

1433

var ADD_CUBICTO = ADD_CONICTO + 1;

caryclark

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

[diff] [blame]

1434

var ADD_CLOSE = ADD_CUBICTO + 1;

1435

var ADD_FILL = ADD_CLOSE + 1;

1436

1437

var PATH_LINE = ADD_FILL + 1;

1438

var PATH_QUAD = PATH_LINE + 1;

caryclark

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

[diff] [blame]

1439

var PATH_CONIC = PATH_QUAD + 1;

1440

var PATH_CUBIC = PATH_CONIC + 1;

caryclark

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

[diff] [blame]

1441

1442

var INTERSECT_LINE = PATH_CUBIC + 1;

1443

var INTERSECT_LINE_2 = INTERSECT_LINE + 1;

1444

var INTERSECT_LINE_NO = INTERSECT_LINE_2 + 1;

1445

var INTERSECT_QUAD_LINE = INTERSECT_LINE_NO + 1;

1446

var INTERSECT_QUAD_LINE_2 = INTERSECT_QUAD_LINE + 1;

1447

var INTERSECT_QUAD_LINE_NO = INTERSECT_QUAD_LINE_2 + 1;

1448

var INTERSECT_QUAD = INTERSECT_QUAD_LINE_NO + 1;

1449

var INTERSECT_QUAD_2 = INTERSECT_QUAD + 1;

1450

var INTERSECT_QUAD_NO = INTERSECT_QUAD_2 + 1;

caryclark

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

[diff] [blame]

1451

var INTERSECT_CONIC_LINE = INTERSECT_QUAD_NO + 1;

1452

var INTERSECT_CONIC_LINE_2 = INTERSECT_CONIC_LINE + 1;

1453

var INTERSECT_CONIC_LINE_NO = INTERSECT_CONIC_LINE_2 + 1;

caryclark

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

[diff] [blame]

1454

var INTERSECT_CONIC_QUAD = INTERSECT_CONIC_LINE_NO + 1;

1455

var INTERSECT_CONIC_QUAD_2 = INTERSECT_CONIC_QUAD + 1;

caryclark

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

[diff] [blame]

1456

var INTERSECT_CONIC_QUAD_3 = INTERSECT_CONIC_QUAD_2 + 1;

1457

var INTERSECT_CONIC_QUAD_4 = INTERSECT_CONIC_QUAD_3 + 1;

1458

var INTERSECT_CONIC_QUAD_NO = INTERSECT_CONIC_QUAD_4 + 1;

caryclark

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

[diff] [blame]

1459

var INTERSECT_CONIC = INTERSECT_CONIC_QUAD_NO + 1;

caryclark

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

[diff] [blame]

1460

var INTERSECT_CONIC_2 = INTERSECT_CONIC + 1;

1461

var INTERSECT_CONIC_NO = INTERSECT_CONIC_2 + 1;

1462

var INTERSECT_SELF_CUBIC = INTERSECT_CONIC_NO + 1;

caryclark

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

[diff] [blame]

1463

var INTERSECT_SELF_CUBIC_NO = INTERSECT_SELF_CUBIC + 1;

1464

var INTERSECT_CUBIC_LINE = INTERSECT_SELF_CUBIC_NO + 1;

1465

var INTERSECT_CUBIC_LINE_2 = INTERSECT_CUBIC_LINE + 1;

1466

var INTERSECT_CUBIC_LINE_3 = INTERSECT_CUBIC_LINE_2 + 1;

1467

var INTERSECT_CUBIC_LINE_NO = INTERSECT_CUBIC_LINE_3 + 1;

1468

var INTERSECT_CUBIC_QUAD = INTERSECT_CUBIC_LINE_NO + 1;

1469

var INTERSECT_CUBIC_QUAD_2 = INTERSECT_CUBIC_QUAD + 1;

1470

var INTERSECT_CUBIC_QUAD_3 = INTERSECT_CUBIC_QUAD_2 + 1;

1471

var INTERSECT_CUBIC_QUAD_4 = INTERSECT_CUBIC_QUAD_3 + 1;

1472

var INTERSECT_CUBIC_QUAD_NO = INTERSECT_CUBIC_QUAD_4 + 1;

1473

var INTERSECT_CUBIC = INTERSECT_CUBIC_QUAD_NO + 1;

1474

var INTERSECT_CUBIC_2 = INTERSECT_CUBIC + 1;

1475

var INTERSECT_CUBIC_3 = INTERSECT_CUBIC_2 + 1;

1476

var INTERSECT_CUBIC_4 = INTERSECT_CUBIC_3 + 1;

1477

// FIXME: add cubic 5- 9

1478

var INTERSECT_CUBIC_NO = INTERSECT_CUBIC_4 + 1;

1479

1480

var SORT_UNARY = INTERSECT_CUBIC_NO + 1;

1481

var SORT_BINARY = SORT_UNARY + 1;

1482

1483

var OP_DIFFERENCE = SORT_BINARY + 1;

1484

var OP_INTERSECT = OP_DIFFERENCE + 1;

1485

var OP_UNION = OP_INTERSECT + 1;

1486

var OP_XOR = OP_UNION + 1;

1487

1488

var MARK_LINE = OP_XOR + 1;

1489

var MARK_QUAD = MARK_LINE + 1;

caryclark

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

[diff] [blame]

1490

var MARK_CONIC = MARK_QUAD + 1;

1491

var MARK_CUBIC = MARK_CONIC + 1;

caryclark

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

[diff] [blame]

1492

var MARK_DONE_LINE = MARK_CUBIC + 1;

1493

var MARK_DONE_QUAD = MARK_DONE_LINE + 1;

caryclark

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

[diff] [blame]

1494

var MARK_DONE_CONIC = MARK_DONE_QUAD + 1;

1495

var MARK_DONE_CUBIC = MARK_DONE_CONIC + 1;

caryclark

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

[diff] [blame]

1496

var MARK_UNSORTABLE_LINE = MARK_DONE_CUBIC + 1;

1497

var MARK_UNSORTABLE_QUAD = MARK_UNSORTABLE_LINE + 1;

caryclark

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

[diff] [blame]

1498

var MARK_UNSORTABLE_CONIC = MARK_UNSORTABLE_QUAD + 1;

1499

var MARK_UNSORTABLE_CUBIC = MARK_UNSORTABLE_CONIC + 1;

caryclark

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

[diff] [blame]

1500

var MARK_SIMPLE_LINE = MARK_UNSORTABLE_CUBIC + 1;

1501

var MARK_SIMPLE_QUAD = MARK_SIMPLE_LINE + 1;

caryclark

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

[diff] [blame]

1502

var MARK_SIMPLE_CONIC = MARK_SIMPLE_QUAD + 1;

1503

var MARK_SIMPLE_CUBIC = MARK_SIMPLE_CONIC + 1;

caryclark

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

[diff] [blame]

1504

var MARK_SIMPLE_DONE_LINE = MARK_SIMPLE_CUBIC + 1;

1505

var MARK_SIMPLE_DONE_QUAD = MARK_SIMPLE_DONE_LINE + 1;

caryclark

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

[diff] [blame]

1506

var MARK_SIMPLE_DONE_CONIC = MARK_SIMPLE_DONE_QUAD + 1;

1507

var MARK_SIMPLE_DONE_CUBIC = MARK_SIMPLE_DONE_CONIC + 1;

caryclark

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

[diff] [blame]

1508

var MARK_DONE_UNARY_LINE = MARK_SIMPLE_DONE_CUBIC + 1;

1509

var MARK_DONE_UNARY_QUAD = MARK_DONE_UNARY_LINE + 1;

caryclark

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

[diff] [blame]

1510

var MARK_DONE_UNARY_CONIC = MARK_DONE_UNARY_QUAD + 1;

1511

var MARK_DONE_UNARY_CUBIC = MARK_DONE_UNARY_CONIC + 1;

caryclark

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

[diff] [blame]

1512

var MARK_ANGLE_LAST = MARK_DONE_UNARY_CUBIC + 1;

1513

1514

var COMPUTED_SET_1 = MARK_ANGLE_LAST + 1;

1515

var COMPUTED_SET_2 = COMPUTED_SET_1 + 1;

1516

caryclark

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

[diff] [blame]

1517

var ANGLE_AFTER = COMPUTED_SET_2 + 1;

caryclark

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

[diff] [blame]

1518

var ANGLE_AFTERPART = ANGLE_AFTER + 1;

caryclark

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

[diff] [blame]

1519

caryclark

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

[diff] [blame]

1520

var ACTIVE_OP = ANGLE_AFTERPART + 1;

caryclark

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

[diff] [blame]

1521

caryclark

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

[diff] [blame]

1522

var COIN_MAIN_SPAN = ACTIVE_OP + 1;

1523

var COIN_OPP_SPAN = COIN_MAIN_SPAN + 1;

1524

1525

var FRAG_TYPE_LAST = COIN_OPP_SPAN;

caryclark

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

[diff] [blame]

1526

1527

var REC_TYPE_UNKNOWN = -1;

1528

var REC_TYPE_PATH = 0;

caryclark

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

[diff] [blame]

1529

var REC_TYPE_PATH2 = 1;

1530

var REC_TYPE_SECT = 2;

1531

var REC_TYPE_ACTIVE = 3;

1532

var REC_TYPE_ADD = 4;

1533

var REC_TYPE_SORT = 5;

1534

var REC_TYPE_OP = 6;

1535

var REC_TYPE_MARK = 7;

1536

var REC_TYPE_COMPUTED = 8;

1537

var REC_TYPE_COIN = 9;

1538

var REC_TYPE_ANGLE = 10;

1539

var REC_TYPE_ACTIVE_OP = 11;

1540

var REC_TYPE_AFTERPART = 12;

caryclark

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

[diff] [blame]

1541

var REC_TYPE_TOP = 13;

caryclark

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

[diff] [blame]

1542

var REC_TYPE_COINCIDENCE = 14;

caryclark

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

[diff] [blame]

1543

var REC_TYPE_ALIGNED = 15;

1544

var REC_TYPE_LAST = REC_TYPE_ALIGNED;

caryclark

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

[diff] [blame]

1545

1546

function strs_to_nums(strs) {

1547

var result = [];

1548

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

1549

var str = strs[idx];

1550

var num = parseFloat(str);

if (isNaN(num)) {

result.push(str);

} else {

result.push(num);

}

}

return result;

}

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

1561

if (regex.test(str)) {

1562

var strs = regex.exec(str);

1563

var result = strs_to_nums(strs);

array.push(id);

array.push(result);

return true;

}

return false;

}

function construct_regexp2(pattern) {

1572

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

1573

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

1574

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

caryclark

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

[diff] [blame]

1575

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

caryclark

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

[diff] [blame]

1576

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

1577

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

1578

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

caryclark

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

[diff] [blame]

1579

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

caryclark

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

[diff] [blame]

1580

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

1581

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

1582

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

caryclark

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

[diff] [blame]

1583

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

caryclark

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

[diff] [blame]

1584

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

caryclark

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

[diff] [blame]

1585

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

caryclark

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

[diff] [blame]

1586

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

1587

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

1588

return new RegExp(escape, 'i');

1589

}

1590

1591

function construct_regexp2c(pattern) {

1592

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

1593

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

caryclark

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

[diff] [blame]

1594

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]

1595

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]

1596

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

1597

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

caryclark

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

[diff] [blame]

1598

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

caryclark

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

[diff] [blame]

1599

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

caryclark

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

[diff] [blame]

1600

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

caryclark

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

[diff] [blame]

1601

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]

1602

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

caryclark

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

[diff] [blame]

1603

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

caryclark

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

[diff] [blame]

1604

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

1605

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

1606

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

caryclark

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

[diff] [blame]

1607

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

caryclark

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

[diff] [blame]

1608

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

1609

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

1610

return new RegExp(escape, 'i');

1611

}

1612

1613

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

1614

var regex = construct_regexp2(pattern);

1615

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

1616

return true;

1617

}

1618

regex = construct_regexp2c(pattern);

1619

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

1620

}

1621

1622

function endsWith(str, suffix) {

1623

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

1624

}

1625

1626

function parse_all(test) {

1627

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

1628

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

1629

var record = [];

1630

var recType = REC_TYPE_UNKNOWN;

1631

var lastLineNo;

1632

var moveX, moveY;

1633

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

1634

var line = lines[lineNo];

1635

if (line.length == 0) {

1636

continue;

1637

}

1638

var opStart = "SkOpSegment::";

1639

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

1640

line = line.substr(opStart.length);

1641

}

1642

var angleStart = "SkOpAngle::";

1643

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

1644

line = line.substr(angleStart.length);

1645

}

caryclark

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

[diff] [blame]

1646

var coinStart = "SkOpCoincidence::";

1647

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

1648

line = line.substr(coinStart.length);

1649

}

caryclark

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

[diff] [blame]

1650

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

caryclark

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

[diff] [blame]

1651

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

caryclark

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

[diff] [blame]

1652

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

caryclark

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

[diff] [blame]

1653

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

caryclark

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

[diff] [blame]

1654

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

caryclark

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

[diff] [blame]

1655

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

1656

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

1657

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

1658

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

caryclark

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

[diff] [blame]

1659

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

caryclark

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

[diff] [blame]

1660

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

caryclark

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

[diff] [blame]

1661

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

caryclark

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

[diff] [blame]

1662

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

1663

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

1664

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

1665

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

1666

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

caryclark

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

[diff] [blame]

1667

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

caryclark

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

[diff] [blame]

1668

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

1669

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

1670

: REC_TYPE_UNKNOWN;

1671

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

1672

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

1673

if (recType != REC_TYPE_UNKNOWN) {

1674

records.push(recType);

1675

records.push(lastLineNo);

1676

records.push(record);

}

record = [];

recType = type;

lastLineNo = lineNo;

}

var found = false;

switch (recType) {

case REC_TYPE_ACTIVE:

1685

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

caryclark

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

[diff] [blame]

1686

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

caryclark

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

[diff] [blame]

1687

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

caryclark

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

[diff] [blame]

1688

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

caryclark

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

[diff] [blame]

1689

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

caryclark

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

[diff] [blame]

1690

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

caryclark

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

[diff] [blame]

1691

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

caryclark

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

[diff] [blame]

1692

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

caryclark

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

[diff] [blame]

1693

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

caryclark

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

[diff] [blame]

1694

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

1695

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

caryclark

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

[diff] [blame]

1696

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

1697

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

caryclark

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

[diff] [blame]

1698

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

1699

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

caryclark

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

[diff] [blame]

1700

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

1701

);

1702

break;

1703

case REC_TYPE_ACTIVE_OP:

1704

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

1705

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

1710

moveX = record[1][0];

1711

moveY = record[1][1];

1712

found = true;

1713

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

1714

record[1].unshift(moveY);

1715

record[1].unshift(moveX);

1716

moveX = record[1][2];

1717

moveY = record[1][3];

1718

found = true;

1719

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

1720

record[1].unshift(moveY);

1721

record[1].unshift(moveX);

1722

moveX = record[1][4];

1723

moveY = record[1][5];

1724

found = true;

caryclark

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

[diff] [blame]

1725

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

1726

record[1].unshift(moveY);

1727

record[1].unshift(moveX);

1728

moveX = record[1][4];

1729

moveY = record[1][5];

1730

found = true;

caryclark

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

[diff] [blame]

1731

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

1732

record[1].unshift(moveY);

1733

record[1].unshift(moveX);

1734

moveX = record[1][6];

1735

moveY = record[1][7];

1736

found = true;

1737

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

1738

found = true;

1739

} else {

1740

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

1741

}

1742

break;

caryclark

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

[diff] [blame]

1743

case REC_TYPE_AFTERPART:

1744

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

1745

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

caryclark

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

[diff] [blame]

1746

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

caryclark

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

[diff] [blame]

1747

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

1748

break;

caryclark

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

[diff] [blame]

1749

case REC_TYPE_ALIGNED:

1750

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

1751

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

1752

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

1753

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

1754

);

1755

break;

caryclark

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

[diff] [blame]

1756

case REC_TYPE_ANGLE:

1757

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

caryclark

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

[diff] [blame]

1758

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

1763

case REC_TYPE_COINCIDENCE:

1764

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

1765

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

1766

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

1767

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

1768

);

1769

break;

caryclark

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

[diff] [blame]

1770

case REC_TYPE_COMPUTED:

1771

found = line == "computed quadratics given"

1772

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

1773

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

1774

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

caryclark

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

[diff] [blame]

1775

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

caryclark

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

[diff] [blame]

1776

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

1777

);

1778

break;

1779

case REC_TYPE_PATH:

caryclark

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

[diff] [blame]

1780

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

1781

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

caryclark

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

[diff] [blame]

1782

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

caryclark

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

[diff] [blame]

1783

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

1788

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

caryclark

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

[diff] [blame]

1789

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

caryclark

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

[diff] [blame]

1790

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

1795

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

1796

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

1797

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

1798

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

1799

" no intersect LINE_VAL LINE_VAL"

1800

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

1801

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

1802

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

1803

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

1804

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

1805

" no intersect QUAD_VAL LINE_VAL"

1806

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

1807

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

1808

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

1809

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

1810

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

1811

" no intersect QUAD_VAL QUAD_VAL"

caryclark

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

[diff] [blame]

1812

caryclark

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

[diff] [blame]

1813

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

1814

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

1815

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

1816

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

1817

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

1818

" no intersect CONIC_VAL LINE_VAL"

caryclark

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

[diff] [blame]

1819

1820

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

1821

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

1822

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

1823

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

1824

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

1825

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

1826

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

1827

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

1828

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

1829

" no intersect CONIC_VAL QUAD_VAL"

1830

caryclark

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

[diff] [blame]

1831

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

1832

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

1833

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

1834

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

1835

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

1836

" no intersect CONIC_VAL CONIC_VAL"

caryclark

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

[diff] [blame]

1837

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

1838

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

1839

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

1840

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

1841

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

1842

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

1843

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

1844

" no intersect CUBIC_VAL LINE_VAL"

1845

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

1846

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

1847

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

1848

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

1849

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

1850

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

1851

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

1852

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

1853

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

1854

" no intersect CUBIC_VAL QUAD_VAL"

1855

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

1856

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

1857

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

1858

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

1859

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

1860

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

1861

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

1862

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

1863

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

1864

" no intersect CUBIC_VAL CUBIC_VAL"

1865

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

1866

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

1867

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

1868

" no self intersect CUBIC_VAL"

);

break;

case REC_TYPE_SORT:

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

1873

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

1874

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

1875

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

1876

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

1877

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

1878

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

1879

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

1880

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

1881

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

1882

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

1883

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

1884

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

1885

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

1886

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

1887

);

1888

if (found) {

1889

record[1].push(hasDone);

1890

record[1].push(hasUnorderable);

1891

record[1].push(hasSmall);

1892

record[1].push(hasTiny);

1893

record[1].push(hasOperand);

1894

record[1].push(hasStop);

1895

}

1896

break;

caryclark

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

[diff] [blame]

1897

case REC_TYPE_TOP:

1898

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

1899

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

1900

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

1901

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

1902

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

1903

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

1904

);

1905

break;

caryclark

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

[diff] [blame]

1906

case REC_TYPE_MARK:

1907

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

caryclark

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

[diff] [blame]

1908

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

1909

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

caryclark

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

[diff] [blame]

1910

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

1911

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

1912

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

1913

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

caryclark

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

[diff] [blame]

1914

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

1915

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

1916

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

1917

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

1918

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

1919

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

1920

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

1921

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

1922

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

1923

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

1924

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

1925

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

1926

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

1927

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

1928

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

1929

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

1930

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

1931

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

caryclark

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

[diff] [blame]

1932

" last segment=IDX span=IDX"

caryclark

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

[diff] [blame]

1933

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

caryclark

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

[diff] [blame]

1934

" last seg=IDX span=IDX"

1935

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

1936

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

1937

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

1938

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

1939

);

caryclark

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

[diff] [blame]

1940

break;

1941

case REC_TYPE_OP:

1942

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

1943

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

1944

found = true;

1945

break;

1946

}

caryclark

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

[diff] [blame]

1947

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

caryclark

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

[diff] [blame]

1948

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

caryclark

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

[diff] [blame]

1949

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

caryclark

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

[diff] [blame]

1950

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

1951

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

1952

);

1953

break;

1954

case REC_TYPE_UNKNOWN:

found = true;

break;

}

if (!found) {

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

1960

}

1961

}

1962

if (recType != REC_TYPE_UNKNOWN) {

1963

records.push(recType);

1964

records.push(lastLineNo);

1965

records.push(record);

1966

}

1967

if (records.length >= 1) {

1968

tests[testIndex] = records;

1969

testLines[testIndex] = lines;

}

}

function init(test) {

1974

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

1975

if (!canvas.getContext) return;

1976

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

1977

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

1978

var unscaledWidth = window.innerWidth - 20;

1979

var unscaledHeight = window.innerHeight - 20;

1980

screenWidth = unscaledWidth;

1981

screenHeight = unscaledHeight;

1982

canvas.width = unscaledWidth * resScale;

1983

canvas.height = unscaledHeight * resScale;

1984

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

1985

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

1986

if (resScale != 1) {

1987

ctx.scale(resScale, resScale);

}

xmin = Infinity;

xmax = -Infinity;

ymin = Infinity;

ymax = -Infinity;

caryclark

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

[diff] [blame]

1993

hasPath = hasAlignedPath = hasComputedPath = false;

caryclark

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

[diff] [blame]

1994

firstActiveSpan = -1;

1995

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

1996

var recType = test[tIndex];

1997

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

1998

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

1999

throw "stop execution";

2000

}

2001

var records = test[tIndex + 2];

2002

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

2003

var fragType = records[recordIndex];

2004

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

2005

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

2006

throw "stop execution";

2007

}

2008

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]

2014

case REC_TYPE_ALIGNED:

2015

hasAlignedPath = true;

caryclark

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

[diff] [blame]

2016

case REC_TYPE_COMPUTED:

2017

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

2018

break;

2019

}

caryclark

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

[diff] [blame]

2020

if (REC_TYPE_COMPUTED == recType) {

2021

hasComputedPath = true;

2022

}

caryclark

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

[diff] [blame]

2023

case REC_TYPE_PATH:

caryclark

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

[diff] [blame]

2024

first = 1;

caryclark

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

[diff] [blame]

2025

switch (fragType) {

2026

case PATH_LINE:

caryclark

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

[diff] [blame]

2027

last = 5;

caryclark

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

[diff] [blame]

2028

break;

caryclark

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

[diff] [blame]

2029

case PATH_CONIC:

caryclark

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

[diff] [blame]

2030

case PATH_QUAD:

caryclark

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

[diff] [blame]

2031

last = 7;

caryclark

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

[diff] [blame]

2032

break;

2033

case PATH_CUBIC:

caryclark

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

[diff] [blame]

2034

last = 9;

caryclark

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

[diff] [blame]

2035

break;

2036

default:

caryclark

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

[diff] [blame]

2037

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

caryclark

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

[diff] [blame]

2038

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

2039

throw "stop execution";

2040

}

2041

if (recType == REC_TYPE_PATH) {

2042

hasPath = true;

2043

}

2044

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]

2051

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]

2059

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

caryclark

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

[diff] [blame]

2060

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

2061

throw "stop execution";

2062

}

2063

if (recType == REC_TYPE_PATH2) {

2064

hasPath = true;

2065

}

2066

break;

caryclark

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

[diff] [blame]

2067

case REC_TYPE_ACTIVE:

2068

if (firstActiveSpan < 0) {

2069

firstActiveSpan = tIndex;

}

first = 1;

switch (fragType) {

case ACTIVE_LINE_SPAN:

2074

last = 5;

2075

break;

caryclark

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

[diff] [blame]

2076

case ACTIVE_CONIC_SPAN:

caryclark

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

[diff] [blame]

2077

case ACTIVE_QUAD_SPAN:

2078

last = 7;

2079

break;

2080

case ACTIVE_CUBIC_SPAN:

last = 9;

break;

default:

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

2085

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]

2095

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

2107

throw "stop execution";

2108

}

2109

break;

caryclark

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

[diff] [blame]

2110

case REC_TYPE_AFTERPART:

switch (fragType) {

case PATH_LINE:

last = 4;

break;

caryclark

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

[diff] [blame]

2115

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

2124

throw "stop execution";

2125

}

2126

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;

2131

break;

2132

case INTERSECT_LINE_2:

2133

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

2134

break;

2135

case INTERSECT_LINE_NO:

2136

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

2137

break;

caryclark

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

[diff] [blame]

2138

case INTERSECT_CONIC_LINE:

2139

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

2140

break;

caryclark

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

[diff] [blame]

2141

case INTERSECT_QUAD_LINE:

2142

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

2143

break;

caryclark

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

[diff] [blame]

2144

case INTERSECT_CONIC_LINE_2:

2145

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

2146

break;

caryclark

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

[diff] [blame]

2147

case INTERSECT_QUAD_LINE_2:

2148

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

2149

break;

caryclark

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

[diff] [blame]

2150

case INTERSECT_CONIC_LINE_NO:

2151

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

2152

break;

caryclark

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

[diff] [blame]

2153

case INTERSECT_QUAD_LINE_NO:

2154

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

2155

break;

caryclark

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

[diff] [blame]

2156

case INTERSECT_CONIC:

2157

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

2158

break;

caryclark

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

[diff] [blame]

2159

case INTERSECT_QUAD:

2160

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

2161

break;

caryclark

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

[diff] [blame]

2162

case INTERSECT_CONIC_2:

2163

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

2164

break;

caryclark

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

[diff] [blame]

2165

case INTERSECT_QUAD_2:

2166

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

2167

break;

caryclark

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

[diff] [blame]

2168

case INTERSECT_CONIC_NO:

2169

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

2170

break;

caryclark

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

[diff] [blame]

2171

case INTERSECT_QUAD_NO:

2172

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

2173

break;

2174

case INTERSECT_SELF_CUBIC:

2175

first = 1; last = 9;

2176

break;

2177

case INTERSECT_SELF_CUBIC_NO:

2178

first = 0; last = 8;

2179

break;

2180

case INTERSECT_CUBIC_LINE:

2181

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

2182

break;

2183

case INTERSECT_CUBIC_LINE_2:

2184

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

2185

break;

2186

case INTERSECT_CUBIC_LINE_3:

2187

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

2188

break;

2189

case INTERSECT_CUBIC_LINE_NO:

2190

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

2191

break;

caryclark

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

[diff] [blame]

2192

case INTERSECT_CONIC_QUAD:

2193

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

2194

break;

2195

case INTERSECT_CONIC_QUAD_2:

2196

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

2197

break;

caryclark

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

[diff] [blame]

2198

case INTERSECT_CONIC_QUAD_3:

2199

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

2200

break;

2201

case INTERSECT_CONIC_QUAD_4:

2202

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

2203

break;

caryclark

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

[diff] [blame]

2204

case INTERSECT_CONIC_QUAD_NO:

2205

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

2206

break;

caryclark

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

[diff] [blame]

2207

case INTERSECT_CUBIC_QUAD:

2208

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

2209

break;

2210

case INTERSECT_CUBIC_QUAD_2:

2211

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

2212

break;

2213

case INTERSECT_CUBIC_QUAD_3:

2214

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

2215

break;

2216

case INTERSECT_CUBIC_QUAD_4:

2217

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

2218

break;

2219

case INTERSECT_CUBIC_QUAD_NO:

2220

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

2221

break;

2222

case INTERSECT_CUBIC:

2223

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

2224

break;

2225

case INTERSECT_CUBIC_2:

2226

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

2227

break;

2228

case INTERSECT_CUBIC_3:

2229

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

2230

break;

2231

case INTERSECT_CUBIC_4:

2232

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

2233

break;

2234

case INTERSECT_CUBIC_NO:

2235

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

2236

break;

2237

default:

2238

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

2239

throw "stop execution";

}

break;

default:

continue;

}

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

2246

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

2247

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

2248

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

2249

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

2250

}

2251

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

2252

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

2253

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

2254

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

2255

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

}

}

}

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

2260

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

2261

var recType = test[tIndex];

2262

var records = test[tIndex + 2];

2263

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

2264

var fragType = records[recordIndex];

2265

var frags = records[recordIndex + 1];

2266

switch (recType) {

2267

case REC_TYPE_ACTIVE_OP:

if (!draw_op) {

break;

}

{

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

2273

curve_extremes(curve, angleBounds);

}

break;

case REC_TYPE_ANGLE:

if (!draw_angle) {

break;

}

caryclark

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

[diff] [blame]

2280

{

caryclark

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

[diff] [blame]

2281

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

2282

curve_extremes(curve, angleBounds);

2283

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

2284

curve_extremes(curve, angleBounds);

2285

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

2286

}

2287

break;

caryclark

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

[diff] [blame]

2288

case REC_TYPE_COINCIDENCE:

2289

if (!draw_coincidence) {

break;

}

{

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

2294

curve_extremes(curve, angleBounds);

2295

}

2296

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

2302

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

2303

curve_extremes(curve, angleBounds);

2304

}

2305

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

2312

curve_extremes(curve, angleBounds);

2313

}

2314

break;

caryclark

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

[diff] [blame]

}

}

}

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

2319

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

2320

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

2321

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

2322

setScale(xmin, xmax, ymin, ymax);

2323

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

caryclark

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

[diff] [blame]

2324

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

caryclark

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

[diff] [blame]

2325

}

2326

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

draw_computed = 0;

}

}

caryclark

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

[diff] [blame]

2331

function curveByIDMatch(test, id, recMatch) {

caryclark

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

[diff] [blame]

2332

var tIndex = -3;

2333

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

caryclark

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

[diff] [blame]

2334

var recType = test[tIndex];

caryclark

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

[diff] [blame]

2335

if (recType == REC_TYPE_OP) {

2336

continue;

2337

}

caryclark

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

[diff] [blame]

2338

if (recType != recMatch) {

caryclark

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

[diff] [blame]

2339

return [];

2340

}

2341

var records = test[tIndex + 2];

2342

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

2343

var fragType = records[recordIndex];

2344

var frags = records[recordIndex + 1];

2345

if (frags[0] == id) {

2346

switch (fragType) {

caryclark

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

[diff] [blame]

2347

case PATH_LINE:

caryclark

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

[diff] [blame]

2348

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

caryclark

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

[diff] [blame]

2349

case PATH_QUAD:

caryclark

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

[diff] [blame]

2350

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

2351

frags[5], frags[6]];

caryclark

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

[diff] [blame]

2352

case PATH_CONIC:

2353

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

2354

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

caryclark

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

[diff] [blame]

2355

case PATH_CUBIC:

caryclark

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

[diff] [blame]

2356

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

2357

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

2358

}

2359

}

2360

}

caryclark

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

[diff] [blame]

}

return [];

}

caryclark

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

[diff] [blame]

2365

function curveByID(test, id) {

2366

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

2367

if (!result.length) {

2368

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]

2374

var tIndex = -3;

2375

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

caryclark

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

[diff] [blame]

2376

var recType = test[tIndex];

caryclark

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

[diff] [blame]

2377

if (recType == REC_TYPE_OP) {

2378

continue;

2379

}

caryclark

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

[diff] [blame]

2380

if (recType != recMatch) {

caryclark

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

[diff] [blame]

2381

return [];

2382

}

2383

var records = test[tIndex + 2];

2384

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

2385

var fragType = records[recordIndex];

2386

var frags = records[recordIndex + 1];

2387

if (frags[0] == id) {

2388

switch (fragType) {

caryclark

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

[diff] [blame]

2389

case PATH_LINE:

caryclark

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

[diff] [blame]

2390

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

caryclark

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

[diff] [blame]

2391

case PATH_QUAD:

caryclark

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

[diff] [blame]

2392

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

2393

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

caryclark

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

[diff] [blame]

2394

case PATH_CONIC:

2395

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

2396

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

caryclark

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

[diff] [blame]

2397

case PATH_CUBIC:

caryclark

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

[diff] [blame]

2398

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

2399

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

2400

}

2401

}

2402

}

caryclark

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

[diff] [blame]

}

return [];

}

caryclark

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

[diff] [blame]

2407

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

2408

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

2409

if (!result.length) {

2410

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]

2416

var tIndex = 0;

caryclark

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

[diff] [blame]

2417

while (tIndex < test.length) {

2418

var recType = test[tIndex];

caryclark

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

[diff] [blame]

2419

if (recType != recMatch) {

caryclark

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

[diff] [blame]

2420

++tIndex;

2421

continue;

caryclark

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

[diff] [blame]

2422

}

2423

var records = test[tIndex + 2];

2424

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

2425

var fragType = records[recordIndex];

2426

var frags = records[recordIndex + 1];

caryclark

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

[diff] [blame]

2427

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

2428

continue;

2429

}

caryclark

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

[diff] [blame]

2430

switch (fragType) {

caryclark

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

[diff] [blame]

2431

case PATH_LINE:

caryclark

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

[diff] [blame]

2432

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

2433

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

2434

continue;

2435

}

2436

return frags[0];

caryclark

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

[diff] [blame]

2437

case PATH_QUAD:

caryclark

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

[diff] [blame]

2438

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

2439

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

2440

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

2441

continue;

2442

}

2443

return frags[0];

caryclark

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

[diff] [blame]

2444

case PATH_CONIC:

2445

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

2446

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

2447

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

2448

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

2449

continue;

2450

}

2451

return frags[0];

caryclark

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

[diff] [blame]

2452

case PATH_CUBIC:

caryclark

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

[diff] [blame]

2453

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

2454

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

2455

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

2456

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

2467

function idByCurve(test, frag, type) {

2468

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

2469

if (!result.length) {

2470

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

}

return result;

}

caryclark

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

[diff] [blame]

2475

function curve_extremes(curve, bounds) {

caryclark

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

[diff] [blame]

2476

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

caryclark

ed0935a

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

[diff] [blame]

2477

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

caryclark

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

[diff] [blame]

2478

var x = curve[index];

2479

var y = curve[index + 1];

2480

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

2481

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

2482

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

2483

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

}

}

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

2488

var srcWidth = x1 - x0;

2489

var srcHeight = y1 - y0;

2490

var usableWidth = screenWidth;

2491

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

2492

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

2493

usableWidth -= (xDigits + yDigits) * 10;

2494

usableWidth -= decimal_places * 10;

if (draw_legend) {

usableWidth -= 40;

}

var hscale = usableWidth / srcWidth;

2499

var vscale = screenHeight / srcHeight;

2500

scale = Math.min(hscale, vscale);

2501

var invScale = 1 / scale;

2502

var sxmin = x0 - invScale * 5;

2503

var symin = y0 - invScale * 10;

2504

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

2505

var symax = y1 + invScale * 10;

2506

srcWidth = sxmax - sxmin;

2507

srcHeight = symax - symin;

2508

hscale = usableWidth / srcWidth;

2509

vscale = screenHeight / srcHeight;

2510

scale = Math.min(hscale, vscale);

srcLeft = sxmin;

srcTop = symin;

}

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

2516

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

2517

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

2518

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

2519

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

2520

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

2521

var _dist = dist * scale;

2522

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

2523

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

2524

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

var divisor = 4;

var endDist;

do {

var ends = [];

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

2530

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

2531

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

ends.push(px);

ends.push(py);

}

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

2536

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

2537

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

2550

ctx.beginPath();

2551

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

2552

ctx.stroke();

2553

var saveAlign = ctx.textAlign;

2554

var saveStyle = ctx.fillStyle;

2555

var saveFont = ctx.font;

2556

ctx.textAlign = "center";

2557

ctx.fillStyle = "black";

2558

ctx.font = "normal 24px Arial";

2559

divisor *= 0.8;

2560

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

2561

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

2562

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

2563

var _px = (px - srcLeft) * scale;

2564

var _py = (py - srcTop) * scale;

2565

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

2566

}

2567

ctx.textAlign = saveAlign;

2568

ctx.fillStyle = saveStyle;

ctx.font = saveFont;

}

function drawPoint(px, py, end) {

caryclark

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

[diff] [blame]

2573

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

2574

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

caryclark

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

[diff] [blame]

2575

var x = drawnPts[pts];

2576

var y = drawnPts[pts + 1];

2577

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

return;

}

}

drawnPts.push(px);

drawnPts.push(py);

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

2584

var _px = (px - srcLeft) * scale;

2585

var _py = (py - srcTop) * scale;

2586

ctx.beginPath();

2587

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

2596

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

}

}

caryclark

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

[diff] [blame]

2600

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]

2614

function drawPoints(ptArray, curveType, drawControls) {

caryclark

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

[diff] [blame]

2615

var count = coordCount(curveType);

caryclark

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

[diff] [blame]

2616

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

2617

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

2618

continue;

2619

}

2620

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

}

}

function drawControlLines(curve, curveType, drawEnd) {

2625

if (curveType == PATH_LINE) {

2626

return;

2627

}

2628

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

2629

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

2630

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

2631

if (curveType == PATH_CUBIC) {

2632

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

2633

if (drawEnd > 1) {

2634

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

2635

if (drawEnd > 2) {

2636

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

2637

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

2638

}

2639

}

2640

} else if (drawEnd > 1) {

2641

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

2652

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

break;

case PATH_QUAD:

var one_t = 1 - t;

var a = one_t * one_t;

2657

var b = 2 * one_t * t;

2658

var c = t * t;

2659

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

2660

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

2661

break;

caryclark

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

[diff] [blame]

2662

case PATH_CONIC:

2663

var one_t = 1 - t;

2664

var a = one_t * one_t;

2665

var b = 2 * one_t * t;

2666

var c = t * t;

2667

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

2668

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

2669

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

2670

xy.x /= d;

2671

xy.y /= d;

2672

break;

caryclark

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

[diff] [blame]

2673

case PATH_CUBIC:

2674

var one_t = 1 - t;

2675

var one_t2 = one_t * one_t;

2676

var a = one_t2 * one_t;

2677

var b = 3 * one_t2 * t;

2678

var t2 = t * t;

2679

var c = 3 * one_t * t2;

2680

var d = t2 * t;

2681

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

2682

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]

2687

caryclark

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

[diff] [blame]

2688

function drawPointAtT(curve, curveType) {

2689

var x, y;

2690

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

2691

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

2692

if (!draw_intersectT) {

2693

return;

2694

}

2695

ctx.fillStyle = "red";

2696

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

2697

}

2698

2699

function drawTAtPointUp(px, py, t) {

2700

var label = t.toFixed(decimal_places);

2701

var _px = (px - srcLeft)* scale;

2702

var _py = (py - srcTop) * scale;

2703

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

2704

}

2705

2706

function drawTAtPointDown(px, py, t) {

2707

var label = t.toFixed(decimal_places);

2708

var _px = (px - srcLeft)* scale;

2709

var _py = (py - srcTop) * scale;

2710

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

2711

}

2712

2713

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

2714

if (collect_bounds) {

2715

if (focus_enabled) {

2716

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

2717

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

2718

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

2719

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

}

return true;

}

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

2724

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

2725

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

2737

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

return;

}

ctx.beginPath();

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

2742

(y1 - srcTop) * scale);

2743

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

2744

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

2761

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,

2771

(ay - srcTop) * scale);

2772

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

2773

(by - srcTop) * scale);

ctx.stroke();

}

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

2778

if (collect_bounds) {

2779

if (focus_enabled) {

2780

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

2781

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

2782

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

2783

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

}

return true;

}

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

2788

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

2789

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

2790

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

2804

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

return;

}

ctx.beginPath();

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

2809

(y1 - srcTop) * scale);

2810

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

2811

(y2 - srcTop) * scale,

2812

(x3 - srcLeft) * scale,

2813

(y3 - srcTop) * scale);

ctx.stroke();

}

function interp(A, B, t) {

2818

return A + (B - A) * t;

2819

}

2820

2821

function interp_quad_coords(x1, x2, x3, t)

2822

{

2823

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

2824

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

2825

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

return abc;

}

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

2830

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

2831

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

2832

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

2833

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

2834

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

2835

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

2836

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

2837

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

2838

var array = [

2839

ax, ay, bx, by, cx, cy

];

return array;

}

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

2845

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,

2857

(ay - srcTop) * scale);

2858

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

2859

(by - srcTop) * scale,

2860

(cx - srcLeft) * scale,

2861

(cy - srcTop) * scale);

ctx.stroke();

}

caryclark

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

[diff] [blame]

2865

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

2866

if (collect_bounds) {

2867

if (focus_enabled) {

2868

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

2869

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

2870

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

2871

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

}

return true;

}

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

2876

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

caryclark

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

[diff] [blame]

2877

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

2878

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

caryclark

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

[diff] [blame]

2879

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

return true;

}

}

drawnConics.push(x1);

2884

drawnConics.push(y1);

2885

drawnConics.push(x2);

2886

drawnConics.push(y2);

2887

drawnConics.push(x3);

2888

drawnConics.push(y3);

drawnCubics.push(w);

return false;

}

var kMaxConicToQuadPOW2 = 5;

2894

2895

function computeQuadPOW2(curve, tol) {

2896

var a = curve[6] - 1;

2897

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

2898

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

2899

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

2900

2901

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

2902

var pow2;

2903

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

if (error <= tol) {

break;

}

error *= 0.25;

}

return pow2;

}

function subdivide_w_value(w) {

2913

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

2914

}

2915

2916

function chop(curve, part1, part2) {

2917

var w = curve[6];

2918

var scale = 1 / (1 + w);

2919

part1[0] = curve[0];

2920

part1[1] = curve[1];

2921

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

2922

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

2923

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

2924

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

2925

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

2926

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

2927

part2[4] = curve[4];

2928

part2[5] = curve[5];

2929

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

2930

}

2931

2932

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

2940

chop(curve, part1, part2);

2941

--level;

2942

subdivide(part1, level, pts);

2943

subdivide(part2, level, pts);

}

}

function chopIntoQuadsPOW2(curve, pow2, pts) {

2948

subdivide(curve, pow2, pts);

return 1 << pow2;

}

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

2953

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

return;

}

ctx.beginPath();

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

2958

(y1 - srcTop) * scale);

2959

var tol = 1 / scale;

2960

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

2961

var pow2 = computeQuadPOW2(curve, tol);

2962

var pts = [];

2963

chopIntoQuadsPOW2(curve, pow2, pts);

2964

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

2965

ctx.quadraticCurveTo(

2966

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

2967

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

}

ctx.stroke();

}

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

2973

var src2w = x2 * w;

2974

var C = x1;

2975

var A = x3 - 2 * src2w + C;

2976

var B = 2 * (src2w - C);

2977

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;

2986

}

2987

2988

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

2989

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

2990

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

2991

var az = conic_eval_denominator(w, t1);

2992

var midT = (t1 + t2) / 2;

2993

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

2994

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

2995

var dz = conic_eval_denominator(w, midT);

2996

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

2997

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

2998

var cz = conic_eval_denominator(w, t2);

2999

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

3000

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

3001

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

3002

var dt = t2 - t1;

3003

var dt_1 = 1 - dt;

caryclark

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

[diff] [blame]

3004

var array = [

caryclark

ed0935a

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

[diff] [blame]

3005

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

caryclark

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

[diff] [blame]

3006

];

caryclark

ed0935a

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

[diff] [blame]

3007

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

3008

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

3009

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

3010

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

3011

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

3012

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

3013

array[6] = partW;

caryclark

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

[diff] [blame]

3014

return array;

3015

}

caryclark

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

[diff] [blame]

3016

caryclark

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

[diff] [blame]

3017

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

3018

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

3027

}

3028

caryclark

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

[diff] [blame]

3029

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

3030

if (collect_bounds) {

3031

if (focus_enabled) {

3032

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

3033

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

3034

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

3035

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

}

return true;

}

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

3040

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

caryclark

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

[diff] [blame]

3041

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

3042

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

caryclark

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

[diff] [blame]

3043

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

return true;

}

}

drawnCubics.push(x1);

3048

drawnCubics.push(y1);

3049

drawnCubics.push(x2);

3050

drawnCubics.push(y2);

3051

drawnCubics.push(x3);

3052

drawnCubics.push(y3);

3053

drawnCubics.push(x4);

3054

drawnCubics.push(y4);

return false;

}

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

3059

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

return;

}

ctx.beginPath();

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

3064

(y1 - srcTop) * scale);

3065

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

3066

(y2 - srcTop) * scale,

3067

(x3 - srcLeft) * scale,

3068

(y3 - srcTop) * scale,

3069

(x4 - srcLeft) * scale,

3070

(y4 - srcTop) * scale);

ctx.stroke();

}

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

3075

{

3076

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

3077

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

3078

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

3079

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

3080

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

3081

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

return abcd;

}

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

3086

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

3087

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

3088

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

3089

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

3090

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

3091

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

3092

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

3093

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

3094

var mx = ex * 27 - ax * 8 - dx;

3095

var my = ey * 27 - ay * 8 - dy;

3096

var nx = fx * 27 - ax - dx * 8;

3097

var ny = fy * 27 - ay - dy * 8;

3098

var bx = (mx * 2 - nx) / 18;

3099

var by = (my * 2 - ny) / 18;

3100

var cx = (nx * 2 - mx) / 18;

3101

var cy = (ny * 2 - my) / 18;

3102

var array = [

3103

ax, ay, bx, by, cx, cy, dx, dy

3104

];

3105

return array;

3106

}

caryclark

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

[diff] [blame]

3107

caryclark

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

[diff] [blame]

3108

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

3109

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,

3123

(ay - srcTop) * scale);

3124

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

3125

(by - srcTop) * scale,

3126

(cx - srcLeft) * scale,

3127

(cy - srcTop) * scale,

3128

(dx - srcLeft) * scale,

3129

(dy - srcTop) * scale);

ctx.stroke();

}

function drawCurve(c) {

3134

switch (c.length) {

3135

case 4:

3136

drawLine(c[0], c[1], c[2], c[3]);

3137

break;

3138

case 6:

3139

drawQuad(c[0], c[1], c[2], c[3], c[4], c[5]);

3140

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3141

case 7:

3142

drawConicWithQuads(c[0], c[1], c[2], c[3], c[4], c[5], c[6]);

3143

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3144

case 8:

3145

drawCubic(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]);

break;

}

}

function boundsWidth(pts) {

3151

var min = pts[0];

3152

var max = pts[0];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3153

var length = pts.length == 7 ? 6 : pts.length;

3154

for (var idx = 2; idx < length; idx += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3155

min = Math.min(min, pts[idx]);

3156

max = Math.max(max, pts[idx]);

}

return max - min;

}

function boundsHeight(pts) {

3162

var min = pts[1];

3163

var max = pts[1];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3164

var length = pts.length == 7 ? 6 : pts.length;

3165

for (var idx = 3; idx < length; idx += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3166

min = Math.min(min, pts[idx]);

3167

max = Math.max(max, pts[idx]);

}

return max - min;

}

function tangent(pts) {

3173

var dx = pts[2] - pts[0];

3174

var dy = pts[3] - pts[1];

3175

if (dx == 0 && dy == 0 && pts.length > 4) {

3176

dx = pts[4] - pts[0];

3177

dy = pts[5] - pts[1];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3178

if (dx == 0 && dy == 0 && pts.length == 8) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3179

dx = pts[6] - pts[0];

3180

dy = pts[7] - pts[1];

3181

}

3182

}

3183

return Math.atan2(-dy, dx);

3184

}

3185

3186

function hodograph(cubic) {

3187

var hodo = [];

3188

hodo[0] = 3 * (cubic[2] - cubic[0]);

3189

hodo[1] = 3 * (cubic[3] - cubic[1]);

3190

hodo[2] = 3 * (cubic[4] - cubic[2]);

3191

hodo[3] = 3 * (cubic[5] - cubic[3]);

3192

hodo[4] = 3 * (cubic[6] - cubic[4]);

3193

hodo[5] = 3 * (cubic[7] - cubic[5]);

return hodo;

}

function hodograph2(cubic) {

3198

var quad = hodograph(cubic);

3199

var hodo = [];

3200

hodo[0] = 2 * (quad[2] - quad[0]);

3201

hodo[1] = 2 * (quad[3] - quad[1]);

3202

hodo[2] = 2 * (quad[4] - quad[2]);

3203

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];

3230

}

3231

3232

function add_valid_ts(s, realRoots, t) {

3233

var foundRoots = 0;

3234

for (var index = 0; index < realRoots; ++index) {

3235

var tValue = s[index];

3236

if (tValue >= 0 && tValue <= 1) {

3237

for (var idx2 = 0; idx2 < foundRoots; ++idx2) {

3238

if (t[idx2] != tValue) {

3239

t[foundRoots++] = tValue;

}

}

}

}

return foundRoots;

}

function quadraticRootsValidT(a, b, c, t) {

3248

var s = [];

3249

var realRoots = quadraticRootsReal(A, B, C, s);

3250

var foundRoots = add_valid_ts(s, realRoots, t);

3251

return foundRoots != 0;

3252

}

3253

3254

function find_cubic_inflections(cubic, tValues) {

3255

var Ax = src[2] - src[0];

3256

var Ay = src[3] - src[1];

3257

var Bx = src[4] - 2 * src[2] + src[0];

3258

var By = src[5] - 2 * src[3] + src[1];

3259

var Cx = src[6] + 3 * (src[2] - src[4]) - src[0];

3260

var Cy = src[7] + 3 * (src[3] - src[5]) - src[1];

3261

return quadraticRootsValidT(Bx * Cy - By * Cx, (Ax * Cy - Ay * Cx),

3262

Ax * By - Ay * Bx, tValues);

3263

}

3264

3265

function dxy_at_t(curve, type, t) {

3266

var dxy = {};

3267

if (type == PATH_QUAD) {

var a = t - 1;

var b = 1 - 2 * t;

var c = t;

dxy.x = a * curve[0] + b * curve[2] + c * curve[4];

3272

dxy.y = a * curve[1] + b * curve[3] + c * curve[5];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3273

} else if (type == PATH_CONIC) {

3274

var p20x = curve[4] - curve[0];

3275

var p20y = curve[5] - curve[1];

3276

var p10xw = (curve[2] - curve[0]) * curve[6];

3277

var p10yw = (curve[3] - curve[1]) * curve[6];

3278

var coeff0x = curve[6] * p20x - p20x;

3279

var coeff0y = curve[6] * p20y - p20y;

3280

var coeff1x = p20x - 2 * p10xw;

3281

var coeff1y = p20y - 2 * p10yw;

3282

dxy.x = t * (t * coeff0x + coeff1x) + p10xw;

3283

dxy.y = t * (t * coeff0y + coeff1y) + p10yw;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3284

} 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;

}

function drawLabel(num, px, py) {

3301

ctx.beginPath();

3302

ctx.arc(px, py, 8, 0, Math.PI*2, true);

3303

ctx.closePath();

3304

ctx.strokeStyle = "rgba(0,0,0, 0.4)";

3305

ctx.lineWidth = num == 0 || num == 3 ? 2 : 1;

3306

ctx.stroke();

3307

ctx.fillStyle = "black";

3308

ctx.font = "normal 10px Arial";

3309

// ctx.rotate(0.001);

3310

ctx.fillText(num, px - 2, py + 3);

3311

// ctx.rotate(-0.001);

3312

}

3313

3314

function drawLabelX(ymin, num, loc) {

3315

var px = (loc - srcLeft) * scale;

3316

var py = (ymin - srcTop) * scale - 20;

3317

drawLabel(num, px, py);

3318

}

3319

3320

function drawLabelY(xmin, num, loc) {

3321

var px = (xmin - srcLeft) * scale - 20;

3322

var py = (loc - srcTop) * scale;

3323

drawLabel(num, px, py);

3324

}

3325

3326

function drawHodoOrigin(hx, hy, hMinX, hMinY, hMaxX, hMaxY) {

3327

ctx.beginPath();

3328

ctx.moveTo(hx, hy - 100);

3329

ctx.lineTo(hx, hy);

3330

ctx.strokeStyle = hMinY < 0 ? "green" : "blue";

ctx.stroke();

ctx.beginPath();

ctx.moveTo(hx, hy);

ctx.lineTo(hx, hy + 100);

3335

ctx.strokeStyle = hMaxY > 0 ? "green" : "blue";

3336

ctx.stroke();

3337

ctx.beginPath();

3338

ctx.moveTo(hx - 100, hy);

3339

ctx.lineTo(hx, hy);

3340

ctx.strokeStyle = hMinX < 0 ? "green" : "blue";

ctx.stroke();

ctx.beginPath();

ctx.moveTo(hx, hy);

ctx.lineTo(hx + 100, hy);

3345

ctx.strokeStyle = hMaxX > 0 ? "green" : "blue";

ctx.stroke();

}

function scalexy(x, y, mag) {

3350

var length = Math.sqrt(x * x + y * y);

return mag / length;

}

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3354

function drawArrow(x, y, dx, dy, s) {

3355

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);

3360

x += dx;

3361

y += dy;

3362

ctx.lineTo((x - srcLeft) * scale, (y - srcTop) * scale);

3363

dx /= 10;

3364

dy /= 10;

3365

ctx.lineTo((x - dy - srcLeft) * scale, (y + dx - srcTop) * scale);

3366

ctx.lineTo((x + dx * 2 - srcLeft) * scale, (y + dy * 2 - srcTop) * scale);

3367

ctx.lineTo((x + dy - srcLeft) * scale, (y - dx - srcTop) * scale);

3368

ctx.lineTo((x - srcLeft) * scale, (y - srcTop) * scale);

3369

ctx.strokeStyle = "rgba(0,75,0, 0.4)";

ctx.stroke();

}

function x_at_t(curve, t) {

3374

var one_t = 1 - t;

3375

if (curve.length == 4) {

3376

return one_t * curve[0] + t * curve[2];

3377

}

3378

var one_t2 = one_t * one_t;

3379

var t2 = t * t;

3380

if (curve.length == 6) {

3381

return one_t2 * curve[0] + 2 * one_t * t * curve[2] + t2 * curve[4];

3382

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3383

if (curve.length == 7) {

3384

return (one_t2 * curve[0] + 2 * one_t * t * curve[2] * curve[6] + t2 * curve[4])

3385

/ (one_t2 +2 * one_t * t * curve[6] + t2);

3386

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3387

var a = one_t2 * one_t;

3388

var b = 3 * one_t2 * t;

3389

var c = 3 * one_t * t2;

3390

var d = t2 * t;

3391

return a * curve[0] + b * curve[2] + c * curve[4] + d * curve[6];

3392

}

3393

3394

function y_at_t(curve, t) {

3395

var one_t = 1 - t;

3396

if (curve.length == 4) {

3397

return one_t * curve[1] + t * curve[3];

3398

}

3399

var one_t2 = one_t * one_t;

3400

var t2 = t * t;

3401

if (curve.length == 6) {

3402

return one_t2 * curve[1] + 2 * one_t * t * curve[3] + t2 * curve[5];

3403

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3404

if (curve.length == 7) {

3405

return (one_t2 * curve[1] + 2 * one_t * t * curve[3] * curve[6] + t2 * curve[5])

3406

/ (one_t2 +2 * one_t * t * curve[6] + t2);

3407

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3408

var a = one_t2 * one_t;

3409

var b = 3 * one_t2 * t;

3410

var c = 3 * one_t * t2;

3411

var d = t2 * t;

3412

return a * curve[1] + b * curve[3] + c * curve[5] + d * curve[7];

3413

}

3414

3415

function drawOrder(curve, label) {

3416

var px = x_at_t(curve, 0.75);

3417

var py = y_at_t(curve, 0.75);

3418

var _px = (px - srcLeft) * scale;

3419

var _py = (py - srcTop) * scale;

3420

ctx.beginPath();

3421

ctx.arc(_px, _py, 15, 0, Math.PI * 2, true);

3422

ctx.closePath();

3423

ctx.fillStyle = "white";

3424

ctx.fill();

3425

if (label == 'L') {

3426

ctx.strokeStyle = "rgba(255,0,0, 1)";

3427

ctx.fillStyle = "rgba(255,0,0, 1)";

3428

} else {

3429

ctx.strokeStyle = "rgba(0,0,255, 1)";

3430

ctx.fillStyle = "rgba(0,0,255, 1)";

3431

}

3432

ctx.stroke();

3433

ctx.font = "normal 16px Arial";

3434

ctx.textAlign = "center";

3435

ctx.fillText(label, _px, _py + 5);

3436

ctx.font = "normal 10px Arial";

3437

}

3438

3439

function drawID(curve, id) {

3440

var px = x_at_t(curve, 0.5);

3441

var py = y_at_t(curve, 0.5);

3442

var _px = (px - srcLeft) * scale;

3443

var _py = (py - srcTop) * scale;

3444

draw_id_at(id, _px, _py);

3445

}

3446

3447

function draw_id_at(id, _px, _py) {

3448

ctx.beginPath();

3449

ctx.arc(_px, _py, 15, 0, Math.PI * 2, true);

3450

ctx.closePath();

3451

ctx.fillStyle = "white";

3452

ctx.fill();

3453

ctx.strokeStyle = "rgba(127,127,0, 1)";

3454

ctx.fillStyle = "rgba(127,127,0, 1)";

3455

ctx.stroke();

3456

ctx.font = "normal 16px Arial";

3457

ctx.textAlign = "center";

3458

ctx.fillText(id, _px, _py + 5);

3459

ctx.font = "normal 10px Arial";

3460

}

3461

3462

function drawLinePartialID(id, x1, y1, x2, y2, t1, t2) {

3463

var curve = [x1, y1, x2, y2];

3464

drawCurvePartialID(id, curve, t1, t2);

3465

}

3466

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3467

function drawLineID(id, x1, y1, x2, y2) {

3468

drawLinePartialID(id, x1, y1, x2, y2, 0, 1);

3469

}

3470

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3471

function drawQuadPartialID(id, x1, y1, x2, y2, x3, y3, t1, t2) {

3472

var curve = [x1, y1, x2, y2, x3, y3];

3473

drawCurvePartialID(id, curve, t1, t2);

3474

}

3475

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3476

function drawQuadID(id, x1, y1, x2, y2, x3, y3) {

3477

drawQuadPartialID(id, x1, y1, x2, y2, x3, y3, 0, 1);

3478

}

3479

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3480

function drawConicPartialID(id, x1, y1, x2, y2, x3, y3, w, t1, t2) {

3481

var curve = [x1, y1, x2, y2, x3, y3, w];

3482

drawCurvePartialID(id, curve, t1, t2);

3483

}

3484

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3485

function drawConicID(id, x1, y1, x2, y2, x3, y3, w) {

3486

drawConicPartialID(id, x1, y1, x2, y2, x3, y3, w, 0, 1);

3487

}

3488

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3489

function drawCubicPartialID(id, x1, y1, x2, y2, x3, y3, x4, y4, t1, t2) {

3490

var curve = [x1, y1, x2, y2, x3, y3, x4, y4];

3491

drawCurvePartialID(id, curve, t1, t2);

3492

}

3493

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3494

function drawCubicID(id, x1, y1, x2, y2, x3, y3, x4, y4) {

3495

drawCubicPartialID(id, x1, y1, x2, y2, x3, y3, x4, y4, 0, 1);

3496

}

3497

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3498

function drawCurvePartialID(id, curve, t1, t2) {

3499

var px = x_at_t(curve, (t1 + t2) / 2);

3500

var py = y_at_t(curve, (t1 + t2) / 2);

3501

var _px = (px - srcLeft) * scale;

3502

var _py = (py - srcTop) * scale;

3503

draw_id_at(id, _px, _py);

3504

}

3505

3506

function drawCurveSpecials(test, curve, type) {

3507

if (pt_labels) {

3508

drawPoints(curve, type, pt_labels == 2);

3509

}

3510

if (control_lines != 0) {

3511

drawControlLines(curve, type, control_lines);

3512

}

3513

if (curve_t) {

3514

drawPointAtT(curve, type);

3515

}

3516

if (draw_midpoint) {

3517

var mid = pointAtT(curve, type, 0.5);

3518

drawPoint(mid.x, mid.y, true);

3519

}

3520

if (draw_id) {

3521

var id = idByCurve(test, curve, type);

if (id >= 0) {

drawID(curve, id);

}

}

if (type == PATH_LINE) {

3527

return;

3528

}

3529

if (draw_deriviatives > 0) {

3530

var d = dxy_at_t(curve, type, 0);

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3531

drawArrow(curve[0], curve[1], d.x, d.y, 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3532

if (draw_deriviatives == 2) {

3533

d = dxy_at_t(curve, type, 1);

3534

if (type == PATH_CUBIC) {

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3535

drawArrow(curve[6], curve[7], d.x, d.y, 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3536

} else {

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3537

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);

3542

d = dxy_at_t(curve, type, 0.5);

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3543

drawArrow(mid.x, mid.y, d.x, d.y, 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3544

}

3545

}

3546

if (type != PATH_CUBIC) {

3547

return;

3548

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3549

if (draw_sequence) {

3550

var ymin = Math.min(curve[1], curve[3], curve[5], curve[7]);

3551

for (var i = 0; i < 8; i+= 2) {

3552

drawLabelX(ymin, i >> 1, curve[i]);

3553

}

3554

var xmin = Math.min(curve[0], curve[2], curve[4], curve[6]);

3555

for (var i = 1; i < 8; i+= 2) {

3556

drawLabelY(xmin, i >> 1, curve[i]);

}

}

}

function logCurves(test) {

3562

for (curves in test) {

3563

var curve = test[curves];

dumpCurve(curve);

}

}

function curveToString(curve) {

3569

var str = "{{";

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3570

var length = curve.length == 7 ? 6 : curve.length;

3571

if (curve.length == 7) {

3572

str += "{";

3573

}

3574

for (i = 0; i < length; i += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3575

str += curve[i].toFixed(decimal_places) + "," + curve[i + 1].toFixed(decimal_places);

3576

if (i < curve.length - 2) {

3577

str += "}, {";

3578

}

3579

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3580

str += "}";

3581

if (curve.length == 7) {

3582

str += "}, " + curve[6].toFixed(decimal_places);

3583

}

3584

str += "}";

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

return str;

}

function dumpCurve(curve) {

3589

console.log(curveToString(curve));

3590

}

3591

3592

function draw(test, lines, title) {

3593

ctx.fillStyle = "rgba(0,0,0, 0.1)";

3594

ctx.font = "normal 50px Arial";

3595

ctx.textAlign = "left";

3596

ctx.fillText(title, 50, 50);

3597

ctx.font = "normal 10px Arial";

3598

ctx.lineWidth = "1.001"; "0.999";

3599

var secondPath = test.length;

var closeCount = 0;

logStart = -1;

logRange = 0;

// find last active rec type at this step

3604

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]

3609

var lastCoin = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3610

var lastSect = 0;

3611

var lastSort = 0;

3612

var lastMark = 0;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3613

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]

3620

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]

3625

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]

3630

topMax = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3631

markMax = 0;

3632

lastIndex = test.length - 3;

3633

for (var tIndex = 0; tIndex < test.length; tIndex += 3) {

3634

var recType = test[tIndex];

3635

if (!typeof recType == 'number' || recType < REC_TYPE_UNKNOWN || recType > REC_TYPE_LAST) {

3636

console.log("unknown rec type: " + recType);

3637

throw "stop execution";

3638

}

3639

// if (curType == recType && curType != REC_TYPE_ADD) {

3640

// continue;

3641

// }

3642

var inStepRange = step_limit == 0 || curStep < step_limit;

3643

curType = recType;

3644

if (recType == REC_TYPE_OP) {

hasOp = true;

continue;

}

if (recType == REC_TYPE_UNKNOWN) {

3649

// these types do not advance step

3650

continue;

3651

}

3652

var bumpStep = false;

3653

var records = test[tIndex + 2];

3654

var fragType = records[0];

3655

if (recType == REC_TYPE_ADD) {

3656

if (records.length != 2) {

3657

console.log("expect only two elements: " + records.length);

3658

throw "stop execution";

3659

}

3660

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) {

3672

secondPath = tIndex;

3673

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3674

if (recType == REC_TYPE_PATH2 && hasOp) {

3675

secondPath = tIndex;

3676

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3677

if (recType == REC_TYPE_ACTIVE) {

3678

++activeMax;

3679

if (!draw_active || !inStepRange) {

continue;

}

lastActive = tIndex;

++activeCount;

bumpStep = true;

}

if (recType == REC_TYPE_ACTIVE_OP) {

3687

++opMax;

3688

if (!draw_op || !inStepRange) {

continue;

}

lastOp = tIndex;

++opCount;

bumpStep = true;

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3695

if (recType == REC_TYPE_AFTERPART) {

3696

if (draw_angle != 3 || !inStepRange) {

continue;

}

lastAngle = tIndex;

++angleCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3703

if (recType == REC_TYPE_ANGLE) {

3704

++angleMax;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3705

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]

3712

if (recType == REC_TYPE_COINCIDENCE) {

3713

++coinMax;

3714

if (!draw_coincidence || !inStepRange) {

continue;

}

lastCoin = tIndex;

++coinCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3721

if (recType == REC_TYPE_SECT) {

3722

if (records.length != 2) {

3723

console.log("expect only two elements: " + records.length);

3724

throw "stop execution";

}

++sectMax;

var sectBump = 1;

switch (fragType) {

case INTERSECT_LINE:

case INTERSECT_QUAD_LINE:

3731

case INTERSECT_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3732

case INTERSECT_CONIC_LINE:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3733

case INTERSECT_CONIC_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3734

case INTERSECT_CONIC:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3735

case INTERSECT_SELF_CUBIC:

3736

case INTERSECT_CUBIC_LINE:

3737

case INTERSECT_CUBIC_QUAD:

3738

case INTERSECT_CUBIC:

3739

sectBump = 1;

3740

break;

3741

case INTERSECT_LINE_2:

3742

case INTERSECT_QUAD_LINE_2:

3743

case INTERSECT_QUAD_2:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3744

case INTERSECT_CONIC_LINE_2:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3745

case INTERSECT_CONIC_QUAD_2:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3746

case INTERSECT_CONIC_2:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3747

case INTERSECT_CUBIC_LINE_2:

3748

case INTERSECT_CUBIC_QUAD_2:

3749

case INTERSECT_CUBIC_2:

3750

sectBump = 2;

3751

break;

3752

case INTERSECT_LINE_NO:

3753

case INTERSECT_QUAD_LINE_NO:

3754

case INTERSECT_QUAD_NO:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3755

case INTERSECT_CONIC_LINE_NO:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3756

case INTERSECT_CONIC_QUAD_NO:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3757

case INTERSECT_CONIC_NO:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3758

case INTERSECT_SELF_CUBIC_NO:

3759

case INTERSECT_CUBIC_LINE_NO:

3760

case INTERSECT_CUBIC_QUAD_NO:

3761

case INTERSECT_CUBIC_NO:

3762

sectBump = 0;

3763

break;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

3764

case INTERSECT_CONIC_QUAD_3:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3765

case INTERSECT_CUBIC_LINE_3:

3766

case INTERSECT_CUBIC_QUAD_3:

3767

case INTERSECT_CUBIC_3:

3768

sectBump = 3;

3769

break;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

3770

case INTERSECT_CONIC_QUAD_4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3771

case INTERSECT_CUBIC_QUAD_4:

3772

case INTERSECT_CUBIC_4:

sectBump = 4;

break;

default:

console.log("missing case " + records.length);

3777

throw "stop execution";

3778

}

3779

sectMax2 += sectBump;

3780

if (draw_intersection <= 1 || !inStepRange) {

continue;

}

lastSect = tIndex;

sectCount += sectBump;

3785

bumpStep = true;

3786

}

3787

if (recType == REC_TYPE_SORT) {

3788

++sortMax;

3789

if (!draw_sort || !inStepRange) {

continue;

}

lastSort = tIndex;

++sortCount;

bumpStep = true;

}

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3796

if (recType == REC_TYPE_TOP) {

3797

++topMax;

3798

if (!draw_top || !inStepRange) {

continue;

}

lastTop = tIndex;

++topCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3805

if (recType == REC_TYPE_MARK) {

3806

++markMax;

3807

if (!draw_mark || !inStepRange) {

continue;

}

lastMark = tIndex;

++markCount;

bumpStep = true;

}

if (bumpStep) {

lastIndex = tIndex;

logStart = test[tIndex + 1];

3817

logRange = records.length / 2;

++curStep;

}

}

stepMax = (draw_add ? addMax : 0)

3822

+ (draw_active ? activeMax : 0)

reed

0dc4dd6

2015-03-24 13:55:33 -0700

[diff] [blame]

3823

+ (draw_angle ? angleMax : 0)

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3824

+ (draw_coincidence ? coinMax : 0)

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3825

+ (draw_op ? opMax : 0)

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3826

+ (draw_sort ? sortMax : 0)

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3827

+ (draw_top ? topMax : 0)

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3828

+ (draw_mark ? markMax : 0)

3829

+ (draw_intersection == 2 ? sectMax : draw_intersection == 3 ? sectMax2 : 0);

3830

if (stepMax == 0) {

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3831

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]

3836

drawnConics = [];

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3837

drawnCubics = [];

3838

focusXmin = focusYmin = Infinity;

3839

focusXmax = focusYmax = -Infinity;

3840

var pathIndex = 0;

3841

var opLetter = 'S';

3842

for (var tIndex = lastIndex; tIndex >= 0; tIndex -= 3) {

3843

var recType = test[tIndex];

3844

var records = test[tIndex + 2];

3845

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

3846

var fragType = records[recordIndex];

3847

if (!typeof fragType == 'number' || fragType < 1 || fragType > FRAG_TYPE_LAST) {

3848

console.log("unknown in range frag type: " + fragType);

3849

throw "stop execution";

3850

}

3851

var frags = records[recordIndex + 1];

3852

focus_enabled = false;

3853

switch (recType) {

3854

case REC_TYPE_COMPUTED:

3855

if (draw_computed == 0) {

continue;

}

ctx.lineWidth = 1;

ctx.strokeStyle = pathIndex == 0 ? "black" : "red";

3860

ctx.fillStyle = "blue";

3861

var drawThis = false;

3862

switch (fragType) {

3863

case PATH_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3864

if ((draw_computed & 0x9) == 1 || ((draw_computed & 8) != 0

3865

&& (draw_computed & 7) == pathIndex)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3866

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]

3871

case PATH_CONIC:

3872

if ((draw_computed & 0xA) == 2 || ((draw_computed & 8) != 0

3873

&& (draw_computed & 7) == pathIndex)) {

3874

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

3875

frags[4], frags[5], frags[6]);

3876

drawThis = true;

3877

}

3878

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3879

case PATH_CUBIC:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3880

if ((draw_computed & 0xC) == 4 || ((draw_computed & 8) != 0

3881

&& (draw_computed & 7) == pathIndex)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3882

drawCubic(frags[0], frags[1], frags[2], frags[3],

3883

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);

3896

throw "stop execution";

3897

}

3898

if (!drawThis || collect_bounds) {

3899

break;

3900

}

3901

drawCurveSpecials(test, frags, fragType);

3902

break;

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3903

case REC_TYPE_ALIGNED:

3904

if (draw_path < 4) {

3905

continue;

3906

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3907

case REC_TYPE_PATH:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3908

case REC_TYPE_PATH2:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3909

if (REC_TYPE_ALIGNED != recType && draw_path >= 4) {

3910

continue;

3911

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

if (!draw_path) {

continue;

}

var firstPath = tIndex < secondPath;

3916

if ((draw_path & (firstPath ? 1 : 2)) == 0) {

continue;

}

ctx.lineWidth = 1;

ctx.strokeStyle = firstPath ? "black" : "red";

3921

ctx.fillStyle = "blue";

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3922

var frags2 = [];

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3923

switch (fragType) {

3924

case PATH_LINE:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3925

for (var i = 0; i < 4; ++ i) { frags2[i] = frags[i + 1]; }

3926

drawLine(frags2[0], frags2[1], frags2[2], frags2[3]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3927

break;

3928

case PATH_QUAD:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3929

for (var i = 0; i < 6; ++ i) { frags2[i] = frags[i + 1]; }

3930

drawQuad(frags2[0], frags2[1], frags2[2], frags2[3],

3931

frags2[4], frags2[5]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3932

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3933

case PATH_CONIC:

3934

for (var i = 0; i < 7; ++ i) { frags2[i] = frags[i + 1]; }

3935

drawConicWithQuads(frags2[0], frags2[1], frags2[2], frags2[3],

3936

frags2[4], frags2[5], frags2[6]);

3937

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3938

case PATH_CUBIC:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3939

for (var i = 0; i < 8; ++ i) { frags2[i] = frags[i + 1]; }

3940

drawCubic(frags2[0], frags2[1], frags2[2], frags2[3],

3941

frags2[4], frags2[5], frags2[6], frags2[7]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3942

break;

3943

default:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3944

console.log("unknown " + recType + " frag type: " + fragType);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3945

throw "stop execution";

3946

}

3947

if (collect_bounds) {

3948

break;

3949

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3950

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;

3955

case OP_DIFFERENCE: opLetter = 'D'; break;

3956

case OP_UNION: opLetter = 'U'; break;

3957

case OP_XOR: opLetter = 'X'; break;

3958

default:

3959

console.log("unknown REC_TYPE_OP frag type: " + fragType);

3960

throw "stop execution";

3961

}

3962

break;

3963

case REC_TYPE_ACTIVE:

3964

if (!draw_active || (step_limit > 0 && tIndex < lastActive)) {

3965

continue;

3966

}

3967

var x1 = frags[SPAN_X1];

3968

var y1 = frags[SPAN_Y1];

3969

var x2 = frags[SPAN_X2];

3970

var y2 = frags[SPAN_Y2];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3971

var x3, y3, x3, y4, w;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3972

ctx.lineWidth = 3;

3973

ctx.strokeStyle = "rgba(0,0,255, 0.3)";

3974

focus_enabled = true;

3975

switch (fragType) {

3976

case ACTIVE_LINE_SPAN:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3977

drawLine(x1, y1, x2, y2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3978

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3979

drawLineID(frags[0], x1, y1, x2, y2);

3980

}

3981

if (pt_labels) {

3982

var curve = [x1, y1, x2, y2];

3983

ctx.fillStyle = "blue";

3984

drawPoints(curve, PATH_LINE, pt_labels == 2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3985

}

3986

break;

3987

case ACTIVE_QUAD_SPAN:

3988

x3 = frags[SPAN_X3];

3989

y3 = frags[SPAN_Y3];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3990

drawQuad(x1, y1, x2, y2, x3, y3);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3991

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3992

drawQuadID(frags[0], x1, y1, x2, y2, x3, y3);

3993

}

3994

if (pt_labels) {

3995

var curve = [x1, y1, x2, y2, x3, y3];

3996

ctx.fillStyle = "blue";

3997

drawPoints(curve, PATH_QUAD, pt_labels == 2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3998

}

3999

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4000

case ACTIVE_CONIC_SPAN:

4001

x3 = frags[SPAN_X3];

4002

y3 = frags[SPAN_Y3];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4003

w = frags[SPAN_K_W];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4004

drawConicWithQuads(x1, y1, x2, y2, x3, y3, w);

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4005

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4006

drawConicID(frags[0], x1, y1, x2, y2, x3, y3, w);

4007

}

4008

if (pt_labels) {

4009

var curve = [x1, y1, x2, y2, x3, y3, w];

4010

ctx.fillStyle = "blue";

4011

drawPoints(curve, PATH_CONIC, pt_labels == 2);

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4012

}

4013

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4014

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]

4019

drawCubic(x1, y1, x2, y2, x3, y3, x4, y4);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4020

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4021

drawCubicID(frags[0], x1, y1, x2, y2, x3, y3, x4, y4);

4022

}

4023

if (pt_labels) {

4024

var curve = [x1, y1, x2, y2, x3, y3, x4, y4];

4025

ctx.fillStyle = "blue";

4026

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);

4031

throw "stop execution";

4032

}

4033

break;

4034

case REC_TYPE_ACTIVE_OP:

4035

if (!draw_op || (step_limit > 0 && tIndex < lastOp)) {

4036

continue;

4037

}

4038

focus_enabled = true;

4039

ctx.lineWidth = 3;

4040

var activeSpan = frags[7] == "1";

4041

ctx.strokeStyle = activeSpan ? "rgba(45,160,0, 0.3)" : "rgba(255,45,0, 0.5)";

4042

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

4043

drawCurve(curve);

4044

if (draw_op > 1) {

4045

drawArc(curve, false, frags[3], frags[4]);

4046

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)"

4055

: closeCount == 1 ? "rgba(0,127,0, 0.3)"

4056

: closeCount == 2 ? "rgba(0,127,127, 0.3)"

4057

: closeCount == 3 ? "rgba(127,127,0, 0.3)"

4058

: "rgba(127,0,127, 0.3)";

4059

focus_enabled = true;

switch (fragType) {

case ADD_MOVETO:

break;

case ADD_LINETO:

if (step_limit == 0 || tIndex >= lastAdd) {

4065

drawLine(frags[0], frags[1], frags[2], frags[3]);

}

break;

case ADD_QUADTO:

if (step_limit == 0 || tIndex >= lastAdd) {

4070

drawQuad(frags[0], frags[1], frags[2], frags[3], frags[4], frags[5]);

4071

}

4072

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4073

case ADD_CONICTO:

4074

if (step_limit == 0 || tIndex >= lastAdd) {

4075

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

4076

frags[4], frags[5], frags[6]);

4077

}

4078

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4079

case ADD_CUBICTO:

4080

if (step_limit == 0 || tIndex >= lastAdd) {

4081

drawCubic(frags[0], frags[1], frags[2], frags[3],

4082

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);

4092

throw "stop execution";

4093

}

4094

break;

4095

case REC_TYPE_ANGLE:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4096

angleBetween = frags[18] == "T";

4097

afterIndex = 0;

4098

if (draw_angle == 0 || draw_angle == 3 || (step_limit > 0 && tIndex < lastAngle)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4099

continue;

4100

}

4101

focus_enabled = true;

4102

ctx.lineWidth = 3;

4103

ctx.strokeStyle = "rgba(127,45,127, 0.3)";

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4104

var leftCurve = curvePartialByID(test, frags[0], frags[4], frags[5]);

4105

var midCurve = curvePartialByID(test, frags[6], frags[10], frags[11]);

4106

var rightCurve = curvePartialByID(test, frags[12], frags[16], frags[17]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4107

drawCurve(leftCurve);

4108

drawCurve(rightCurve);

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4109

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]

4110

drawCurve(midCurve);

4111

if (draw_angle > 1) {

4112

drawOrder(leftCurve, 'L');

4113

drawOrder(rightCurve, 'R');

4114

}

4115

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4116

case REC_TYPE_AFTERPART:

4117

if (draw_angle != 3 || (step_limit > 0 && tIndex < lastAngle)) {

4118

continue;

4119

}

4120

ctx.strokeStyle = afterIndex == 0 ? "rgba(255,0,0, 1.0)"

4121

: (afterIndex == 1) == angleBetween ? "rgba(0,128,0, 1.0)"

4122

: "rgba(0,0,255, 1.0)";

4123

switch (fragType) {

4124

case PATH_LINE:

4125

drawLine(frags[0], frags[1], frags[2], frags[3]);

4126

break;

4127

case PATH_QUAD:

4128

drawQuad(frags[0], frags[1], frags[2], frags[3],

4129

frags[4], frags[5]);

4130

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4131

case PATH_CONIC:

4132

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

4133

frags[4], frags[5], frags[6]);

4134

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4135

case PATH_CUBIC:

4136

drawCubic(frags[0], frags[1], frags[2], frags[3],

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4137

frags[4], frags[5], frags[6], frags[7]);

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4138

break;

4139

default:

4140

console.log("unknown REC_TYPE_AFTERPART frag type: " + fragType);

4141

throw "stop execution";

4142

}

4143

++afterIndex;

4144

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

4145

case REC_TYPE_COINCIDENCE:

4146

if (!draw_coincidence || (step_limit > 0 && tIndex < lastCoin)) {

4147

continue;

4148

}

4149

focus_enabled = true;

4150

ctx.lineWidth = 3;

4151

ctx.strokeStyle = "rgba(127,45,63, 0.3)";

4152

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

4153

drawCurve(curve);

4154

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4155

case REC_TYPE_SECT:

4156

if (!draw_intersection) {

4157

continue;

4158

}

4159

if (draw_intersection != 1 && (step_limit > 0 && tIndex < lastSect)) {

4160

continue;

4161

}

4162

// draw_intersection == 1 : show all

4163

// draw_intersection == 2 : step == 0 ? show all : show intersection line #step

4164

// draw_intersection == 3 : step == 0 ? show all : show intersection #step

4165

ctx.lineWidth = 1;

4166

ctx.strokeStyle = "rgba(0,0,255, 0.3)";

4167

ctx.fillStyle = "blue";

4168

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;

4178

break;

4179

case INTERSECT_LINE_2:

4180

f.push(5, 6, 0, 10);

4181

f.push(8, 9, 7, 15);

4182

c1s = 1; c1l = 4; c2s = 11; c2l = 4;

4183

break;

4184

case INTERSECT_LINE_NO:

4185

c1s = 0; c1l = 4; c2s = 4; c2l = 4;

4186

break;

4187

case INTERSECT_QUAD_LINE:

4188

f.push(7, 8, 0, 9);

4189

c1s = 1; c1l = 6; c2s = 10; c2l = 4;

4190

break;

4191

case INTERSECT_QUAD_LINE_2:

4192

f.push(7, 8, 0, 12);

4193

f.push(10, 11, 9, 17);

4194

c1s = 1; c1l = 6; c2s = 13; c2l = 4;

4195

break;

4196

case INTERSECT_QUAD_LINE_NO:

4197

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;

4202

break;

4203

case INTERSECT_QUAD_2:

4204

f.push(7, 8, 0, 12);

4205

f.push(10, 11, 9, 19);

4206

c1s = 1; c1l = 6; c2s = 13; c2l = 6;

4207

break;

4208

case INTERSECT_QUAD_NO:

4209

c1s = 0; c1l = 6; c2s = 6; c2l = 6;

4210

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4211

case INTERSECT_CONIC_LINE:

4212

f.push(8, 9, 0, 10);

4213

c1s = 1; c1l = 7; c2s = 11; c2l = 4;

4214

break;

4215

case INTERSECT_CONIC_LINE_2:

4216

f.push(8, 9, 0, 12);

4217

f.push(11, 12, 10, 18);

4218

c1s = 1; c1l = 7; c2s = 14; c2l = 4;

4219

break;

4220

case INTERSECT_CONIC_LINE_NO:

4221

c1s = 0; c1l = 7; c2s = 7; c2l = 4;

4222

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4223

case INTERSECT_CONIC_QUAD:

4224

f.push(8, 9, 0, 10);

4225

c1s = 1; c1l = 7; c2s = 11; c2l = 6;

4226

break;

4227

case INTERSECT_CONIC_QUAD_2:

4228

f.push(8, 9, 0, 12);

4229

f.push(11, 12, 10, 18);

4230

c1s = 1; c1l = 7; c2s = 14; c2l = 6;

4231

break;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

4232

case INTERSECT_CONIC_QUAD_3:

4233

f.push(8, 9, 0, 15);

4234

f.push(11, 12, 10, 21);

4235

f.push(14, 15, 13, 22);

4236

c1s = 1; c1l = 7; c2s = 17; c2l = 6;

4237

break;

4238

case INTERSECT_CONIC_QUAD_4:

4239

f.push(8, 9, 0, 18);

4240

f.push(11, 12, 10, 24);

4241

f.push(14, 15, 13, 25);

4242

f.push(17, 18, 16, 26);

4243

c1s = 1; c1l = 7; c2s = 20; c2l = 6;

4244

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4245

case INTERSECT_CONIC_QUAD_NO:

4246

c1s = 0; c1l = 7; c2s = 7; c2l = 6;

4247

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4248

case INTERSECT_CONIC:

4249

f.push(8, 9, 0, 10);

4250

c1s = 1; c1l = 7; c2s = 11; c2l = 7;

4251

break;

4252

case INTERSECT_CONIC_2:

4253

f.push(8, 9, 0, 13);

4254

f.push(11, 12, 10, 21);

4255

c1s = 1; c1l = 7; c2s = 14; c2l = 7;

4256

break;

4257

case INTERSECT_CONIC_NO:

4258

c1s = 0; c1l = 7; c2s = 7; c2l = 7;

4259

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4260

case INTERSECT_SELF_CUBIC:

4261

f.push(9, 10, 0, 11);

4262

c1s = 1; c1l = 8; c2s = 0; c2l = 0;

4263

break;

4264

case INTERSECT_SELF_CUBIC_NO:

4265

c1s = 0; c1l = 8; c2s = 0; c2l = 0;

4266

break;

4267

case INTERSECT_CUBIC_LINE:

4268

f.push(9, 10, 0, 11);

4269

c1s = 1; c1l = 8; c2s = 12; c2l = 4;

4270

break;

4271

case INTERSECT_CUBIC_LINE_2:

4272

f.push(9, 10, 0, 14);

4273

f.push(12, 13, 11, 19);

4274

c1s = 1; c1l = 8; c2s = 15; c2l = 4;

4275

break;

4276

case INTERSECT_CUBIC_LINE_3:

4277

f.push(9, 10, 0, 17);

4278

f.push(12, 13, 11, 22);

4279

f.push(15, 16, 14, 23);

4280

c1s = 1; c1l = 8; c2s = 18; c2l = 4;

4281

break;

4282

case INTERSECT_CUBIC_QUAD_NO:

4283

c1s = 0; c1l = 8; c2s = 8; c2l = 6;

4284

break;

4285

case INTERSECT_CUBIC_QUAD:

4286

f.push(9, 10, 0, 11);

4287

c1s = 1; c1l = 8; c2s = 12; c2l = 6;

4288

break;

4289

case INTERSECT_CUBIC_QUAD_2:

4290

f.push(9, 10, 0, 14);

4291

f.push(12, 13, 11, 21);

4292

c1s = 1; c1l = 8; c2s = 15; c2l = 6;

4293

break;

4294

case INTERSECT_CUBIC_QUAD_3:

4295

f.push(9, 10, 0, 17);

4296

f.push(12, 13, 11, 24);

4297

f.push(15, 16, 14, 25);

4298

c1s = 1; c1l = 8; c2s = 18; c2l = 6;

4299

break;

4300

case INTERSECT_CUBIC_QUAD_4:

4301

f.push(9, 10, 0, 20);

4302

f.push(12, 13, 11, 27);

4303

f.push(15, 16, 14, 28);

4304

f.push(18, 19, 17, 29);

4305

c1s = 1; c1l = 8; c2s = 21; c2l = 6;

4306

break;

4307

case INTERSECT_CUBIC_LINE_NO:

4308

c1s = 0; c1l = 8; c2s = 8; c2l = 4;

4309

break;

4310

case INTERSECT_CUBIC:

4311

f.push(9, 10, 0, 11);

4312

c1s = 1; c1l = 8; c2s = 12; c2l = 8;

4313

break;

4314

case INTERSECT_CUBIC_2:

4315

f.push(9, 10, 0, 14);

4316

f.push(12, 13, 11, 23);

4317

c1s = 1; c1l = 8; c2s = 15; c2l = 8;

4318

break;

4319

case INTERSECT_CUBIC_3:

4320

f.push(9, 10, 0, 17);

4321

f.push(12, 13, 11, 26);

4322

f.push(15, 16, 14, 27);

4323

c1s = 1; c1l = 8; c2s = 18; c2l = 8;

4324

break;

4325

case INTERSECT_CUBIC_4:

4326

f.push(9, 10, 0, 20);

4327

f.push(12, 13, 11, 29);

4328

f.push(15, 16, 14, 30);

4329

f.push(18, 19, 17, 31);

4330

c1s = 1; c1l = 8; c2s = 21; c2l = 8;

4331

break;

4332

case INTERSECT_CUBIC_NO:

4333

c1s = 0; c1l = 8; c2s = 8; c2l = 8;

4334

break;

4335

default:

4336

console.log("unknown REC_TYPE_SECT frag type: " + fragType);

4337

throw "stop execution";

4338

}

4339

if (draw_intersection != 1) {

4340

var id = -1;

4341

var curve;

4342

switch (c1l) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4343

case 4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4344

drawLine(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3]);

4345

if (draw_id) {

4346

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3]];

4347

id = idByCurve(test, curve, PATH_LINE);

}

break;

case 6:

drawQuad(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

4352

frags[c1s + 4], frags[c1s + 5]);

4353

if (draw_id) {

4354

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

4355

frags[c1s + 4], frags[c1s + 5]];

4356

id = idByCurve(test, curve, PATH_QUAD);

4357

}

4358

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4359

case 7:

4360

drawConicWithQuads(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

4361

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6]);

4362

if (draw_id) {

4363

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

4364

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6]];

4365

id = idByCurve(test, curve, PATH_CONIC);

4366

}

4367

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4368

case 8:

4369

drawCubic(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

4370

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6], frags[c1s + 7]);

4371

if (draw_id) {

4372

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

4373

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6], frags[c1s + 7]];

4374

id = idByCurve(test, curve, PATH_CUBIC);

}

break;

}

if (id >= 0) {

drawID(curve, id);

}

id = -1;

switch (c2l) {

case 0:

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4385

case 4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4386

drawLine(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3]);

4387

if (draw_id) {

4388

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3]];

4389

id = idByCurve(test, curve, PATH_LINE);

}

break;

case 6:

drawQuad(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

4394

frags[c2s + 4], frags[c2s + 5]);

4395

if (draw_id) {

4396

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

4397

frags[c2s + 4], frags[c2s + 5]];

4398

id = idByCurve(test, curve, PATH_QUAD);

4399

}

4400

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4401

case 7:

4402

drawConicWithQuads(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

4403

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6]);

4404

if (draw_id) {

4405

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

4406

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6]];

4407

id = idByCurve(test, curve, PATH_CONIC);

4408

}

4409

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4410

case 8:

4411

drawCubic(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

4412

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6], frags[c2s + 7]);

4413

if (draw_id) {

4414

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

4415

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6], frags[c2s + 7]];

4416

id = idByCurve(test, curve, PATH_CUBIC);

}

break;

}

if (id >= 0) {

drawID(curve, id);

}

}

if (collect_bounds) {

4425

break;

4426

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4427

if (draw_intersection != 3 || step_limit == 0 || tIndex >= lastSect) {

4428

for (var idx = 0; idx < f.length; idx += 4) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4429

drawPoint(frags[f[idx]], frags[f[idx + 1]], true);

4430

}

4431

}

4432

if (!draw_intersectT) {

4433

break;

4434

}

4435

ctx.fillStyle = "red";

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4436

if (draw_intersection != 3 || step_limit == 0 || tIndex >= lastSect) {

4437

for (var idx = 0; idx < f.length; idx += 4) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4438

drawTAtPointUp(frags[f[idx]], frags[f[idx + 1]], frags[f[idx + 2]]);

4439

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)";

4449

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);

4458

throw "stop execution";

4459

}

4460

break;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

4461

case REC_TYPE_TOP:

4462

if (!draw_top || (step_limit > 0 && tIndex < lastTop)) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = "rgba(127,127,0, 0.5)";

4467

focus_enabled = true;

4468

{

4469

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

4470

drawCurve(curve);

4471

var type = PATH_LINE + (curve.length / 2 - 2);

4472

var mid = pointAtT(curve, type, 0.5);

4473

var d = dxy_at_t(curve, type, 0.5);

4474

drawArrow(mid.x, mid.y, d.x, d.y, 0.3);

4475

}

4476

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4477

case REC_TYPE_MARK:

4478

if (!draw_mark || (step_limit > 0 && tIndex < lastMark)) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = fragType >= MARK_DONE_LINE ?

4483

"rgba(127,0,127, 0.5)" : "rgba(127,127,0, 0.5)";

4484

focus_enabled = true;

switch (fragType) {

case MARK_LINE:

case MARK_DONE_LINE:

case MARK_UNSORTABLE_LINE:

4489

case MARK_SIMPLE_LINE:

4490

case MARK_SIMPLE_DONE_LINE:

4491

case MARK_DONE_UNARY_LINE:

4492

drawLinePartial(frags[1], frags[2], frags[3], frags[4],

4493

frags[5], frags[9]);

4494

if (draw_id) {

4495

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:

4502

case MARK_SIMPLE_QUAD:

4503

case MARK_SIMPLE_DONE_QUAD:

4504

case MARK_DONE_UNARY_QUAD:

4505

drawQuadPartial(frags[1], frags[2], frags[3], frags[4],

4506

frags[5], frags[6], frags[7], frags[11]);

4507

if (draw_id) {

4508

drawQuadPartialID(frags[0], frags[1], frags[2], frags[3], frags[4],

4509

frags[5], frags[6], frags[7], frags[11]);

}

break;

case MARK_CUBIC:

case MARK_DONE_CUBIC:

4514

case MARK_UNSORTABLE_CUBIC:

4515

case MARK_SIMPLE_CUBIC:

4516

case MARK_SIMPLE_DONE_CUBIC:

4517

case MARK_DONE_UNARY_CUBIC:

4518

drawCubicPartial(frags[1], frags[2], frags[3], frags[4],

4519

frags[5], frags[6], frags[7], frags[8], frags[9], frags[13]);

4520

if (draw_id) {

4521

drawCubicPartialID(frags[0], frags[1], frags[2], frags[3], frags[4],

4522

frags[5], frags[6], frags[7], frags[8], frags[9], frags[13]);

4523

}

4524

break;

4525

case MARK_ANGLE_LAST:

4526

// FIXME: ignored for now

4527

break;

4528

default:

4529

console.log("unknown REC_TYPE_MARK frag type: " + fragType);

4530

throw "stop execution";

}

break;

default:

continue;

}

}

switch (recType) {

case REC_TYPE_SORT:

if (!draw_sort || (step_limit > 0 && tIndex < lastSort)) {

4540

break;

4541

}

4542

var angles = []; // use tangent lines to describe arcs

var windFrom = [];

var windTo = [];

var opp = [];

var minXY = Number.MAX_VALUE;

4547

var partial;

4548

focus_enabled = true;

4549

var someUnsortable = false;

4550

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

4551

var fragType = records[recordIndex];

4552

var frags = records[recordIndex + 1];

4553

var unsortable = (fragType == SORT_UNARY && frags[14]) ||

4554

(fragType == SORT_BINARY && frags[16]);

4555

someUnsortable |= unsortable;

switch (fragType) {

case SORT_UNARY:

case SORT_BINARY:

partial = curvePartialByID(test, frags[0], frags[6], frags[8]);

4560

break;

4561

default:

4562

console.log("unknown REC_TYPE_SORT frag type: " + fragType);

4563

throw "stop execution";

4564

}

4565

var dx = boundsWidth(partial);

4566

var dy = boundsHeight(partial);

4567

minXY = Math.min(minXY, dx * dx + dy * dy);

4568

if (collect_bounds) {

4569

continue;

4570

}

4571

angles.push(tangent(partial));

4572

var from = frags[12];

var to = frags[12];

var sgn = frags[10];

if (sgn < 0) {

from -= frags[11];

} else if (sgn > 0) {

4578

to -= frags[11];

4579

}

4580

windFrom.push(from + (unsortable ? "!" : ""));

4581

windTo.push(to + (unsortable ? "!" : ""));

4582

opp.push(fragType == SORT_BINARY);

4583

if (draw_sort == 1) {

4584

drawOrder(partial, frags[12]);

4585

} else {

4586

drawOrder(partial, (recordIndex / 2) + 1);

4587

}

4588

}

4589

var radius = Math.sqrt(minXY) / 2 * scale;

4590

radius = Math.min(50, radius);

4591

var scaledRadius = radius / scale;

4592

var centerX = partial[0];

4593

var centerY = partial[1];

4594

if (collect_bounds) {

4595

if (focus_enabled) {

4596

focusXmin = Math.min(focusXmin, centerX - scaledRadius);

4597

focusYmin = Math.min(focusYmin, centerY - scaledRadius);

4598

focusXmax = Math.max(focusXmax, centerX + scaledRadius);

4599

focusYmax = Math.max(focusYmax, centerY + scaledRadius);

}

break;

}

break;

default:

break;

}

}

if (collect_bounds) {

4609

return;

4610

}

4611

if (draw_log && logStart >= 0) {

4612

ctx.font = "normal 10px Arial";

4613

ctx.textAlign = "left";

4614

ctx.beginPath();

4615

var top = screenHeight - 20 - (logRange + 2) * 10;

4616

ctx.rect(50, top, screenWidth - 100, (logRange + 2) * 10);

4617

ctx.fillStyle = "white";

4618

ctx.fill();

4619

ctx.fillStyle = "rgba(0,0,0, 0.5)";

4620

if (logStart > 0) {

4621

ctx.fillText(lines[logStart - 1], 50, top + 8);

4622

}

4623

ctx.fillStyle = "black";

4624

for (var idx = 0; idx < logRange; ++idx) {

4625

ctx.fillText(lines[logStart + idx], 50, top + 18 + 10 * idx);

4626

}

4627

ctx.fillStyle = "rgba(0,0,0, 0.5)";

4628

if (logStart + logRange < lines.length) {

4629

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]

4634

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4635

// drawBox(pos++, "yellow", "black", opLetter, true, '');

4636

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_intersection > 1 ? sectCount : sectMax2, draw_intersection, intersectionKey);

4637

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_add ? addCount : addMax, draw_add, addKey);

4638

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_active ? activeCount : activeMax, draw_active, activeKey);

4639

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]

4640

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]

4641

drawBox(pos++, "rgba(127,127,0, 0.3)", "black", draw_op ? opCount : opMax, draw_op, opKey);

4642

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]

4643

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]

4644

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]

4645

drawBox(pos++, "black", "white",

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

4646

(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]

4647

drawBox(pos++, "rgba(0,63,0, 0.7)", "white",

4648

(new Array('Q', 'Q', 'C', 'QC', 'Qc', 'Cq'))[draw_computed],

4649

draw_computed != 0, computedKey);

4650

drawBox(pos++, "green", "black", step_limit, drawSomething, '');

4651

drawBox(pos++, "green", "black", stepMax, drawSomething, '');

4652

drawBox(pos++, "rgba(255,0,0, 0.6)", "black", lastIndex, drawSomething & draw_log, '');

4653

drawBox(pos++, "rgba(255,0,0, 0.6)", "black", test.length - 1, drawSomething & draw_log, '');

if (curve_t) {

drawCurveTControl();

}

ctx.font = "normal 20px Arial";

4658

ctx.fillStyle = "rgba(0,0,0, 0.3)";

4659

ctx.textAlign = "right";

4660

ctx.fillText(scale.toFixed(decimal_places) + 'x' , screenWidth - 10, screenHeight - 5);

4661

}

4662

if (draw_hints) {

4663

ctx.font = "normal 10px Arial";

4664

ctx.fillStyle = "rgba(0,0,0, 0.5)";

4665

ctx.textAlign = "right";

4666

var y = 4;

4667

ctx.fillText("control lines : " + controlLinesKey, ctx.screenWidthwidth - 10, pos * 50 + y++ * 10);

4668

ctx.fillText("curve t : " + curveTKey, screenWidth - 10, pos * 50 + y++ * 10);

4669

ctx.fillText("deriviatives : " + deriviativesKey, screenWidth - 10, pos * 50 + y++ * 10);

4670

ctx.fillText("intersect t : " + intersectTKey, screenWidth - 10, pos * 50 + y++ * 10);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4671

ctx.fillText("log : " + logKey, screenWidth - 10, pos * 50 + y++ * 10);

4672

ctx.fillText("log curve : " + logCurvesKey, screenWidth - 10, pos * 50 + y++ * 10);

4673

ctx.fillText("mid point : " + midpointKey, screenWidth - 10, pos * 50 + y++ * 10);

4674

ctx.fillText("points : " + ptsKey, screenWidth - 10, pos * 50 + y++ * 10);

4675

ctx.fillText("sequence : " + sequenceKey, screenWidth - 10, pos * 50 + y++ * 10);

4676

ctx.fillText("xy : " + xyKey, screenWidth - 10, pos * 50 + y++ * 10);

}

}

function drawBox(y, backC, foreC, str, enable, label) {

4681

ctx.beginPath();

4682

ctx.fillStyle = backC;

4683

ctx.rect(screenWidth - 40, y * 50 + 10, 40, 30);

4684

ctx.fill();

4685

ctx.font = "normal 16px Arial";

4686

ctx.fillStyle = foreC;

4687

ctx.textAlign = "center";

4688

ctx.fillText(str, screenWidth - 20, y * 50 + 32);

4689

if (!enable) {

4690

ctx.fillStyle = "rgba(255,255,255, 0.5)";

ctx.fill();

}

if (label != '') {

ctx.font = "normal 9px Arial";

4695

ctx.fillStyle = "black";

4696

ctx.fillText(label, screenWidth - 47, y * 50 + 40);

}

}

function drawCurveTControl() {

4701

ctx.lineWidth = 2;

4702

ctx.strokeStyle = "rgba(0,0,0, 0.3)";

4703

ctx.beginPath();

4704

ctx.rect(screenWidth - 80, 40, 28, screenHeight - 80);

4705

ctx.stroke();

4706

var ty = 40 + curveT * (screenHeight - 80);

4707

ctx.beginPath();

4708

ctx.moveTo(screenWidth - 80, ty);

4709

ctx.lineTo(screenWidth - 85, ty - 5);

4710

ctx.lineTo(screenWidth - 85, ty + 5);

4711

ctx.lineTo(screenWidth - 80, ty);

4712

ctx.fillStyle = "rgba(0,0,0, 0.6)";

4713

ctx.fill();

4714

var num = curveT.toFixed(decimal_places);

4715

ctx.font = "normal 10px Arial";

4716

ctx.textAlign = "left";

4717

ctx.fillText(num, screenWidth - 78, ty);

4718

}

4719

4720

function ptInTControl() {

4721

var e = window.event;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4722

var tgt = e.target || e.srcElement;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4723

var left = tgt.offsetLeft;

4724

var top = tgt.offsetTop;

4725

var x = (e.clientX - left);

4726

var y = (e.clientY - top);

4727

if (x < screenWidth - 80 || x > screenWidth - 50) {

4728

return false;

4729

}

4730

if (y < 40 || y > screenHeight - 80) {

4731

return false;

4732

}

4733

curveT = (y - 40) / (screenHeight - 120);

4734

if (curveT < 0 || curveT > 1) {

4735

throw "stop execution";

}

return true;

}

function drawTop() {

if (tests[testIndex] == null) {

4742

var str = testDivs[testIndex].textContent;

4743

parse_all(str);

4744

var title = testDivs[testIndex].id.toString();

4745

testTitles[testIndex] = title;

4746

}

4747

init(tests[testIndex]);

redraw();

}

function redraw() {

if (focus_on_selection) {

4753

collect_bounds = true;

4754

draw(tests[testIndex], testLines[testIndex], testTitles[testIndex]);

4755

collect_bounds = false;

4756

if (focusXmin < focusXmax && focusYmin < focusYmax) {

4757

setScale(focusXmin, focusXmax, focusYmin, focusYmax);

}

}

ctx.beginPath();

ctx.fillStyle = "white";

4762

ctx.rect(0, 0, screenWidth, screenHeight);

4763

ctx.fill();

4764

draw(tests[testIndex], testLines[testIndex], testTitles[testIndex]);

4765

}

4766

4767

function dumpCurvePartial(test, id, t0, t1) {

4768

var curve = curveByID(test, id);

4769

var name = ["line", "quad", "cubic"][curve.length / 2 - 2];

4770

console.log("id=" + id + " " + name + "=" + curveToString(curve)

4771

+ " t0=" + t0 + " t1=" + t1

4772

+ " partial=" + curveToString(curvePartialByID(test, id, t0, t1)));

4773

}

4774

4775

function dumpAngleTest(test, id, t0, t1) {

4776

var curve = curveByID(test, id);

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4777

console.log(" { {" + curveToString(curve) + "}, "

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4778

+ curve.length / 2 + ", " + t0 + ", " + t1 + ", {} }, //");

4779

}

4780

4781

function dumpLogToConsole() {

if (logStart < 0) {

return;

}

var test = tests[testIndex];

4786

var recType = REC_TYPE_UNKNOWN;

4787

var records;

4788

for (var index = 0; index < test.length; index += 3) {

4789

var lastLineNo = test[index + 1];

4790

if (lastLineNo >= logStart && lastLineNo < logStart + logRange) {

4791

recType = test[index];

4792

records = test[index + 2];

break;

}

}

if (recType == REC_TYPE_UNKNOWN) {

4797

return;

4798

}

4799

var lines = testLines[testIndex];

4800

for (var idx = 0; idx < logRange; ++idx) {

4801

var line = lines[logStart + idx];

4802

console.log(line);

4803

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

4804

var fragType = records[recordIndex];

4805

var frags = records[recordIndex + 1];

4806

if (recType == REC_TYPE_ANGLE && fragType == ANGLE_AFTER) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4807

dumpCurvePartial(test, frags[0], frags[4], frags[5]);

4808

dumpCurvePartial(test, frags[6], frags[10], frags[11]);

4809

dumpCurvePartial(test, frags[12], frags[16], frags[17]);

4810

console.log("\nstatic IntersectData intersectDataSet[] = { //");

4811

dumpAngleTest(test, frags[0], frags[4], frags[5]);

4812

dumpAngleTest(test, frags[6], frags[10], frags[11]);

4813

dumpAngleTest(test, frags[12], frags[16], frags[17]);

4814

console.log("}; //");

}

}

}

}

var activeKey = 'a';

var pathKey = 'b';

var pathBackKey = 'B';

4823

var centerKey = 'c';

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

4824

var coincidenceKey = 'C';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4825

var addKey = 'd';

4826

var deriviativesKey = 'f';

4827

var angleKey = 'g';

4828

var angleBackKey = 'G';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4829

var intersectionKey = 'i';

4830

var intersectionBackKey = 'I';

4831

var sequenceKey = 'j';

4832

var midpointKey = 'k';

4833

var logKey = 'l';

4834

var logToConsoleKey = 'L';

var markKey = 'm';

var sortKey = 'o';

var opKey = 'p';

var opBackKey = 'P';

var computedKey = 'q';

4840

var computedBackKey = 'Q';

4841

var stepKey = 's';

4842

var stepBackKey = 'S';

4843

var intersectTKey = 't';

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

4844

var topKey = 'T';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4845

var curveTKey = 'u';

4846

var controlLinesBackKey = 'V';

4847

var controlLinesKey = 'v';

4848

var ptsKey = 'x';

4849

var xyKey = 'y';

4850

var logCurvesKey = 'z';

4851

var focusKey = '`';

4852

var idKey = '.';

4853

var retinaKey = '\\';

4854

4855

function doKeyPress(evt) {

4856

var char = String.fromCharCode(evt.charCode);

4857

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]

4874

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4875

break;

4876

case addKey:

4877

draw_add ^= true;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4878

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4879

break;

4880

case angleKey:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4881

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]

4890

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4891

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

4892

case coincidenceKey:

4893

draw_coincidence ^= true;

4894

redraw();

4895

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4896

case controlLinesBackKey:

4897

control_lines = (control_lines + 3) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4898

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4899

break;

4900

case controlLinesKey:

4901

control_lines = (control_lines + 1) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4902

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4903

break;

4904

case computedBackKey:

4905

draw_computed = (draw_computed + 5) % 6;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4906

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4907

break;

4908

case computedKey:

4909

draw_computed = (draw_computed + 1) % 6;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4910

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:

4920

draw_deriviatives = (draw_deriviatives + 1) % 3;

redraw();

break;

case focusKey:

focus_on_selection ^= true;

4925

setScale(xmin, xmax, ymin, ymax);

4926

redraw();

4927

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

case idKey:

draw_id ^= true;

redraw();

break;

case intersectionBackKey:

4933

draw_intersection = (draw_intersection + 3) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4934

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4935

break;

4936

case intersectionKey:

4937

draw_intersection = (draw_intersection + 1) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4938

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4939

break;

4940

case intersectTKey:

4941

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;

4970

redraw();

4971

break;

4972

case pathKey:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

4973

draw_path = (draw_path + 1) % (4 + (hasAlignedPath ? 3 : 0));

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4974

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4975

break;

4976

case pathBackKey:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

4977

draw_path = (draw_path + 3 + (hasAlignedPath ? 3 : 0)) % (4 + (hasAlignedPath ? 3 : 0));

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4978

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4979

break;

4980

case ptsKey:

4981

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) {

4999

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]

5014

case xyKey:

5015

debug_xy = (debug_xy + 1) % 3;

redraw();

break;

case '-':

focusWasOn = focus_on_selection;

5020

if (focusWasOn) {

5021

focus_on_selection = false;

scale /= 1.2;

} else {

scale /= 2;

calcLeftTop();

}

redraw();

focus_on_selection = focusWasOn;

break;

case '=':

case '+':

focusWasOn = focus_on_selection;

5033

if (focusWasOn) {

5034

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) {

5058

var char = evt.keyCode;

5059

var preventDefault = false;

5060

switch (char) {

5061

case 37: // left arrow

if (evt.shiftKey) {

testIndex -= 9;

}

if (--testIndex < 0)

testIndex = tests.length - 1;

5067

drawTop();

5068

preventDefault = true;

5069

break;

5070

case 39: // right arrow

if (evt.shiftKey) {

testIndex += 9;

}

if (++testIndex >= tests.length)

5075

testIndex = 0;

5076

drawTop();

5077

preventDefault = true;

5078

break;

5079

}

5080

if (preventDefault) {

5081

evt.preventDefault();

return false;

}

return true;

}

(function() {

var hidden = "hidden";

5089

5090

// Standards:

5091

if (hidden in document)

5092

document.addEventListener("visibilitychange", onchange);

5093

else if ((hidden = "mozHidden") in document)

5094

document.addEventListener("mozvisibilitychange", onchange);

5095

else if ((hidden = "webkitHidden") in document)

5096

document.addEventListener("webkitvisibilitychange", onchange);

5097

else if ((hidden = "msHidden") in document)

5098

document.addEventListener("msvisibilitychange", onchange);

5099

// IE 9 and lower:

5100

else if ('onfocusin' in document)

5101

document.onfocusin = document.onfocusout = onchange;

5102

// All others:

5103

else

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

5104

window.onpageshow = window.onpagehide

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

5105

= window.onfocus = window.onblur = onchange;

5106

5107

function onchange (evt) {

5108

var v = 'visible', h = 'hidden',

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

5109

evtMap = {

5110

focus:v, focusin:v, pageshow:v, blur:h, focusout:h, pagehide:h

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

5111

};

5112

5113

evt = evt || window.event;

5114

if (evt.type in evtMap)

5115

document.body.className = evtMap[evt.type];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

5116

else

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

5117

document.body.className = this[hidden] ? "hidden" : "visible";

}

})();

function calcXY() {

var e = window.event;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

5123

var tgt = e.target || e.srcElement;

caryclark