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

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

[diff] [blame]

caryclark

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

[diff] [blame]

1031

var testDivs = [

Cary Clark

5de5233

2018-08-30 12:58:23 -0400

[diff] [blame]

1032

crbug_526025,

caryclark

30b9fdd

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

[diff] [blame]

1033

];

caryclark

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

[diff] [blame]

1034

1035

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;

1044

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]

1049

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;

1054

var control_lines = 0;

1055

var curve_t = false;

1056

var debug_xy = 1;

1057

var focus_enabled = false;

1058

var focus_on_selection = false;

1059

var step_limit = 0;

1060

var draw_active = false;

1061

var draw_add = false;

1062

var draw_angle = 0;

caryclark

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

[diff] [blame]

1063

var draw_coincidence = false;

caryclark

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

[diff] [blame]

1064

var draw_deriviatives = 0;

Cary Clark

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

[diff] [blame]

1065

var draw_direction = false;

caryclark

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

[diff] [blame]

1066

var draw_hints = false;

caryclark

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

[diff] [blame]

1067

var draw_id = false;

1068

var draw_intersection = 0;

1069

var draw_intersectT = false;

1070

var draw_legend = true;

1071

var draw_log = false;

1072

var draw_mark = false;

1073

var draw_midpoint = false;

1074

var draw_op = 0;

1075

var draw_sequence = false;

1076

var draw_sort = 0;

caryclark

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

[diff] [blame]

1077

var draw_top = false;

caryclark

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

[diff] [blame]

1078

var draw_path = 3;

1079

var draw_computed = 0;

1080

var retina_scale = !!window.devicePixelRatio;

var activeCount = 0;

var addCount = 0;

var angleCount = 0;

caryclark

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

[diff] [blame]

1085

var coinCount = 0;

caryclark

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

[diff] [blame]

1086

var opCount = 0;

1087

var sectCount = 0;

1088

var sortCount = 0;

caryclark

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

[diff] [blame]

1089

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]

1094

var coinMax = 0;

caryclark

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

[diff] [blame]

1095

var sectMax = 0;

1096

var sectMax2 = 0;

1097

var sortMax = 0;

caryclark

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

[diff] [blame]

1098

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]

1104

var hasAlignedPath = false;

caryclark

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

[diff] [blame]

1105

var hasComputedPath = false;

caryclark

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

[diff] [blame]

1106

var angleBetween = false;

1107

var afterIndex = 0;

caryclark

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

[diff] [blame]

1108

1109

var firstActiveSpan = -1;

var logStart = -1;

var logRange = 0;

var SPAN_ID = 0;

var SPAN_X1 = SPAN_ID + 1;

1115

var SPAN_Y1 = SPAN_X1 + 1;

1116

var SPAN_X2 = SPAN_Y1 + 1;

1117

var SPAN_Y2 = SPAN_X2 + 1;

caryclark

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

[diff] [blame]

1118

caryclark

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

[diff] [blame]

1119

var SPAN_L_TX = SPAN_Y2 + 1;

caryclark

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

[diff] [blame]

1120

var SPAN_L_TY = SPAN_L_TX + 1;

caryclark

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

[diff] [blame]

1121

var SPAN_L_OTHER = SPAN_L_TY + 1;

caryclark

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

[diff] [blame]

1122

var SPAN_L_OTHERT = SPAN_L_OTHER + 1;

1123

var SPAN_L_OTHERI = SPAN_L_OTHERT + 1;

1124

var SPAN_L_SUM = SPAN_L_OTHERI + 1;

1125

var SPAN_L_VAL = SPAN_L_SUM + 1;

1126

var SPAN_L_OPP = SPAN_L_VAL + 1;

1127

1128

var SPAN_X3 = SPAN_Y2 + 1;

1129

var SPAN_Y3 = SPAN_X3 + 1;

caryclark

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

[diff] [blame]

1130

caryclark

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

[diff] [blame]

1131

var SPAN_Q_TX = SPAN_Y3 + 1;

caryclark

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

[diff] [blame]

1132

var SPAN_Q_TY = SPAN_Q_TX + 1;

caryclark

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

[diff] [blame]

1133

var SPAN_Q_OTHER = SPAN_Q_TY + 1;

caryclark

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

[diff] [blame]

1134

var SPAN_Q_OTHERT = SPAN_Q_OTHER + 1;

1135

var SPAN_Q_OTHERI = SPAN_Q_OTHERT + 1;

1136

var SPAN_Q_SUM = SPAN_Q_OTHERI + 1;

1137

var SPAN_Q_VAL = SPAN_Q_SUM + 1;

1138

var SPAN_Q_OPP = SPAN_Q_VAL + 1;

1139

caryclark

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

[diff] [blame]

1140

var SPAN_K_W = SPAN_Y3 + 1;

caryclark

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

[diff] [blame]

1141

var SPAN_K_TX = SPAN_K_W + 1;

caryclark

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

[diff] [blame]

1142

var SPAN_K_TY = SPAN_K_TX + 1;

caryclark

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

[diff] [blame]

1143

var SPAN_K_OTHER = SPAN_K_TY + 1;

caryclark

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

[diff] [blame]

1144

var SPAN_K_OTHERT = SPAN_K_OTHER + 1;

1145

var SPAN_K_OTHERI = SPAN_K_OTHERT + 1;

1146

var SPAN_K_SUM = SPAN_K_OTHERI + 1;

1147

var SPAN_K_VAL = SPAN_K_SUM + 1;

1148

var SPAN_K_OPP = SPAN_K_VAL + 1;

1149

caryclark

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

[diff] [blame]

1150

var SPAN_X4 = SPAN_Y3 + 1;

1151

var SPAN_Y4 = SPAN_X4 + 1;

caryclark

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

[diff] [blame]

1152

caryclark

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

[diff] [blame]

1153

var SPAN_C_TX = SPAN_Y4 + 1;

caryclark

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

[diff] [blame]

1154

var SPAN_C_TY = SPAN_C_TX + 1;

caryclark

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

[diff] [blame]

1155

var SPAN_C_OTHER = SPAN_C_TY + 1;

caryclark

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

[diff] [blame]

1156

var SPAN_C_OTHERT = SPAN_C_OTHER + 1;

1157

var SPAN_C_OTHERI = SPAN_C_OTHERT + 1;

1158

var SPAN_C_SUM = SPAN_C_OTHERI + 1;

1159

var SPAN_C_VAL = SPAN_C_SUM + 1;

1160

var SPAN_C_OPP = SPAN_C_VAL + 1;

1161

1162

var ACTIVE_LINE_SPAN = 1;

1163

var ACTIVE_QUAD_SPAN = ACTIVE_LINE_SPAN + 1;

caryclark

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

[diff] [blame]

1164

var ACTIVE_CONIC_SPAN = ACTIVE_QUAD_SPAN + 1;

1165

var ACTIVE_CUBIC_SPAN = ACTIVE_CONIC_SPAN + 1;

caryclark

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

[diff] [blame]

1166

1167

var ADD_MOVETO = ACTIVE_CUBIC_SPAN + 1;

1168

var ADD_LINETO = ADD_MOVETO + 1;

1169

var ADD_QUADTO = ADD_LINETO + 1;

caryclark

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

[diff] [blame]

1170

var ADD_CONICTO = ADD_QUADTO + 1;

1171

var ADD_CUBICTO = ADD_CONICTO + 1;

caryclark

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

[diff] [blame]

1172

var ADD_CLOSE = ADD_CUBICTO + 1;

1173

var ADD_FILL = ADD_CLOSE + 1;

1174

1175

var PATH_LINE = ADD_FILL + 1;

1176

var PATH_QUAD = PATH_LINE + 1;

caryclark

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

[diff] [blame]

1177

var PATH_CONIC = PATH_QUAD + 1;

1178

var PATH_CUBIC = PATH_CONIC + 1;

caryclark

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

[diff] [blame]

1179

1180

var INTERSECT_LINE = PATH_CUBIC + 1;

1181

var INTERSECT_LINE_2 = INTERSECT_LINE + 1;

1182

var INTERSECT_LINE_NO = INTERSECT_LINE_2 + 1;

1183

var INTERSECT_QUAD_LINE = INTERSECT_LINE_NO + 1;

1184

var INTERSECT_QUAD_LINE_2 = INTERSECT_QUAD_LINE + 1;

1185

var INTERSECT_QUAD_LINE_NO = INTERSECT_QUAD_LINE_2 + 1;

1186

var INTERSECT_QUAD = INTERSECT_QUAD_LINE_NO + 1;

1187

var INTERSECT_QUAD_2 = INTERSECT_QUAD + 1;

1188

var INTERSECT_QUAD_NO = INTERSECT_QUAD_2 + 1;

caryclark

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

[diff] [blame]

1189

var INTERSECT_CONIC_LINE = INTERSECT_QUAD_NO + 1;

1190

var INTERSECT_CONIC_LINE_2 = INTERSECT_CONIC_LINE + 1;

1191

var INTERSECT_CONIC_LINE_NO = INTERSECT_CONIC_LINE_2 + 1;

caryclark

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

[diff] [blame]

1192

var INTERSECT_CONIC_QUAD = INTERSECT_CONIC_LINE_NO + 1;

1193

var INTERSECT_CONIC_QUAD_2 = INTERSECT_CONIC_QUAD + 1;

caryclark

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

[diff] [blame]

1194

var INTERSECT_CONIC_QUAD_3 = INTERSECT_CONIC_QUAD_2 + 1;

1195

var INTERSECT_CONIC_QUAD_4 = INTERSECT_CONIC_QUAD_3 + 1;

1196

var INTERSECT_CONIC_QUAD_NO = INTERSECT_CONIC_QUAD_4 + 1;

caryclark

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

[diff] [blame]

1197

var INTERSECT_CONIC = INTERSECT_CONIC_QUAD_NO + 1;

caryclark

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

[diff] [blame]

1198

var INTERSECT_CONIC_2 = INTERSECT_CONIC + 1;

1199

var INTERSECT_CONIC_NO = INTERSECT_CONIC_2 + 1;

1200

var INTERSECT_SELF_CUBIC = INTERSECT_CONIC_NO + 1;

caryclark

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

[diff] [blame]

1201

var INTERSECT_SELF_CUBIC_NO = INTERSECT_SELF_CUBIC + 1;

1202

var INTERSECT_CUBIC_LINE = INTERSECT_SELF_CUBIC_NO + 1;

1203

var INTERSECT_CUBIC_LINE_2 = INTERSECT_CUBIC_LINE + 1;

1204

var INTERSECT_CUBIC_LINE_3 = INTERSECT_CUBIC_LINE_2 + 1;

1205

var INTERSECT_CUBIC_LINE_NO = INTERSECT_CUBIC_LINE_3 + 1;

1206

var INTERSECT_CUBIC_QUAD = INTERSECT_CUBIC_LINE_NO + 1;

1207

var INTERSECT_CUBIC_QUAD_2 = INTERSECT_CUBIC_QUAD + 1;

1208

var INTERSECT_CUBIC_QUAD_3 = INTERSECT_CUBIC_QUAD_2 + 1;

1209

var INTERSECT_CUBIC_QUAD_4 = INTERSECT_CUBIC_QUAD_3 + 1;

1210

var INTERSECT_CUBIC_QUAD_NO = INTERSECT_CUBIC_QUAD_4 + 1;

1211

var INTERSECT_CUBIC = INTERSECT_CUBIC_QUAD_NO + 1;

1212

var INTERSECT_CUBIC_2 = INTERSECT_CUBIC + 1;

1213

var INTERSECT_CUBIC_3 = INTERSECT_CUBIC_2 + 1;

1214

var INTERSECT_CUBIC_4 = INTERSECT_CUBIC_3 + 1;

1215

// FIXME: add cubic 5- 9

1216

var INTERSECT_CUBIC_NO = INTERSECT_CUBIC_4 + 1;

1217

1218

var SORT_UNARY = INTERSECT_CUBIC_NO + 1;

1219

var SORT_BINARY = SORT_UNARY + 1;

1220

1221

var OP_DIFFERENCE = SORT_BINARY + 1;

1222

var OP_INTERSECT = OP_DIFFERENCE + 1;

1223

var OP_UNION = OP_INTERSECT + 1;

1224

var OP_XOR = OP_UNION + 1;

1225

1226

var MARK_LINE = OP_XOR + 1;

1227

var MARK_QUAD = MARK_LINE + 1;

caryclark

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

[diff] [blame]

1228

var MARK_CONIC = MARK_QUAD + 1;

1229

var MARK_CUBIC = MARK_CONIC + 1;

caryclark

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

[diff] [blame]

1230

var MARK_DONE_LINE = MARK_CUBIC + 1;

1231

var MARK_DONE_QUAD = MARK_DONE_LINE + 1;

caryclark

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

[diff] [blame]

1232

var MARK_DONE_CONIC = MARK_DONE_QUAD + 1;

1233

var MARK_DONE_CUBIC = MARK_DONE_CONIC + 1;

caryclark

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

[diff] [blame]

1234

var MARK_UNSORTABLE_LINE = MARK_DONE_CUBIC + 1;

1235

var MARK_UNSORTABLE_QUAD = MARK_UNSORTABLE_LINE + 1;

caryclark

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

[diff] [blame]

1236

var MARK_UNSORTABLE_CONIC = MARK_UNSORTABLE_QUAD + 1;

1237

var MARK_UNSORTABLE_CUBIC = MARK_UNSORTABLE_CONIC + 1;

caryclark

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

[diff] [blame]

1238

var MARK_SIMPLE_LINE = MARK_UNSORTABLE_CUBIC + 1;

1239

var MARK_SIMPLE_QUAD = MARK_SIMPLE_LINE + 1;

caryclark

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

[diff] [blame]

1240

var MARK_SIMPLE_CONIC = MARK_SIMPLE_QUAD + 1;

1241

var MARK_SIMPLE_CUBIC = MARK_SIMPLE_CONIC + 1;

caryclark

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

[diff] [blame]

1242

var MARK_SIMPLE_DONE_LINE = MARK_SIMPLE_CUBIC + 1;

1243

var MARK_SIMPLE_DONE_QUAD = MARK_SIMPLE_DONE_LINE + 1;

caryclark

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

[diff] [blame]

1244

var MARK_SIMPLE_DONE_CONIC = MARK_SIMPLE_DONE_QUAD + 1;

1245

var MARK_SIMPLE_DONE_CUBIC = MARK_SIMPLE_DONE_CONIC + 1;

caryclark

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

[diff] [blame]

1246

var MARK_DONE_UNARY_LINE = MARK_SIMPLE_DONE_CUBIC + 1;

1247

var MARK_DONE_UNARY_QUAD = MARK_DONE_UNARY_LINE + 1;

caryclark

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

[diff] [blame]

1248

var MARK_DONE_UNARY_CONIC = MARK_DONE_UNARY_QUAD + 1;

1249

var MARK_DONE_UNARY_CUBIC = MARK_DONE_UNARY_CONIC + 1;

caryclark

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

[diff] [blame]

1250

var MARK_ANGLE_LAST = MARK_DONE_UNARY_CUBIC + 1;

1251

1252

var COMPUTED_SET_1 = MARK_ANGLE_LAST + 1;

1253

var COMPUTED_SET_2 = COMPUTED_SET_1 + 1;

1254

caryclark

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

[diff] [blame]

1255

var ANGLE_AFTER = COMPUTED_SET_2 + 1;

caryclark

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

[diff] [blame]

1256

var ANGLE_AFTERPART = ANGLE_AFTER + 1;

caryclark

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

[diff] [blame]

1257

caryclark

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

[diff] [blame]

1258

var ACTIVE_OP = ANGLE_AFTERPART + 1;

caryclark

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

[diff] [blame]

1259

caryclark

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

[diff] [blame]

1260

var COIN_MAIN_SPAN = ACTIVE_OP + 1;

1261

var COIN_OPP_SPAN = COIN_MAIN_SPAN + 1;

1262

1263

var FRAG_TYPE_LAST = COIN_OPP_SPAN;

caryclark

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

[diff] [blame]

1264

1265

var REC_TYPE_UNKNOWN = -1;

1266

var REC_TYPE_PATH = 0;

caryclark

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

[diff] [blame]

1267

var REC_TYPE_PATH2 = 1;

1268

var REC_TYPE_SECT = 2;

1269

var REC_TYPE_ACTIVE = 3;

1270

var REC_TYPE_ADD = 4;

1271

var REC_TYPE_SORT = 5;

1272

var REC_TYPE_OP = 6;

1273

var REC_TYPE_MARK = 7;

1274

var REC_TYPE_COMPUTED = 8;

1275

var REC_TYPE_COIN = 9;

1276

var REC_TYPE_ANGLE = 10;

1277

var REC_TYPE_ACTIVE_OP = 11;

1278

var REC_TYPE_AFTERPART = 12;

caryclark

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

[diff] [blame]

1279

var REC_TYPE_TOP = 13;

caryclark

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

[diff] [blame]

1280

var REC_TYPE_COINCIDENCE = 14;

caryclark

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

[diff] [blame]

1281

var REC_TYPE_ALIGNED = 15;

1282

var REC_TYPE_LAST = REC_TYPE_ALIGNED;

caryclark

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

[diff] [blame]

1283

1284

function strs_to_nums(strs) {

1285

var result = [];

1286

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

1287

var str = strs[idx];

1288

var num = parseFloat(str);

if (isNaN(num)) {

result.push(str);

} else {

result.push(num);

}

}

return result;

}

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

1299

if (regex.test(str)) {

1300

var strs = regex.exec(str);

1301

var result = strs_to_nums(strs);

array.push(id);

array.push(result);

return true;

}

return false;

}

function construct_regexp2(pattern) {

1310

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

1311

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

1312

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

caryclark

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

[diff] [blame]

1313

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

caryclark

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

[diff] [blame]

1314

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

1315

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

1316

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

caryclark

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

[diff] [blame]

1317

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

caryclark

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

[diff] [blame]

1318

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

Cary Clark

5de5233

2018-08-30 12:58:23 -0400

[diff] [blame]

1319

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

1320

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

1321

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

caryclark

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

[diff] [blame]

1322

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

caryclark

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

[diff] [blame]

1323

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

caryclark

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

[diff] [blame]

1324

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

1325

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

1326

return new RegExp(escape, 'i');

1327

}

1328

1329

function construct_regexp2c(pattern) {

1330

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

1331

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

caryclark

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

[diff] [blame]

1332

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]

1333

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]

1334

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

1335

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

caryclark

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

[diff] [blame]

1336

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

caryclark

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

[diff] [blame]

1337

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

caryclark

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

[diff] [blame]

1338

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

Cary Clark

5de5233

2018-08-30 12:58:23 -0400

[diff] [blame]

1339

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

1340

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

1341

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

caryclark

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

[diff] [blame]

1342

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

1343

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

1344

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

caryclark

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

[diff] [blame]

1345

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

caryclark

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

[diff] [blame]

1346

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

1347

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

1348

return new RegExp(escape, 'i');

1349

}

1350

1351

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

1352

var regex = construct_regexp2(pattern);

1353

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

1354

return true;

1355

}

1356

regex = construct_regexp2c(pattern);

1357

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

1358

}

1359

1360

function endsWith(str, suffix) {

1361

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

1362

}

1363

1364

function parse_all(test) {

1365

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

1366

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

1367

var record = [];

1368

var recType = REC_TYPE_UNKNOWN;

1369

var lastLineNo;

1370

var moveX, moveY;

1371

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

1372

var line = lines[lineNo];

1373

if (line.length == 0) {

1374

continue;

1375

}

1376

var opStart = "SkOpSegment::";

1377

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

1378

line = line.substr(opStart.length);

1379

}

1380

var angleStart = "SkOpAngle::";

1381

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

1382

line = line.substr(angleStart.length);

1383

}

caryclark

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

[diff] [blame]

1384

var coinStart = "SkOpCoincidence::";

1385

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

1386

line = line.substr(coinStart.length);

1387

}

caryclark

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

[diff] [blame]

1388

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

caryclark

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

[diff] [blame]

1389

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

caryclark

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

[diff] [blame]

1390

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

caryclark

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

[diff] [blame]

1391

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

caryclark

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

[diff] [blame]

1392

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

caryclark

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

[diff] [blame]

1393

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

1394

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

1395

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

1396

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

caryclark

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

[diff] [blame]

1397

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

caryclark

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

[diff] [blame]

1398

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

caryclark

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

[diff] [blame]

1399

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

caryclark

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

[diff] [blame]

1400

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

1401

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

Cary Clark

59d5a0e

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

[diff] [blame]

1402

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

caryclark

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

[diff] [blame]

1403

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

1404

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

caryclark

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

[diff] [blame]

1405

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

caryclark

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

[diff] [blame]

1406

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

1407

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

1408

: REC_TYPE_UNKNOWN;

1409

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

1410

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

1411

if (recType != REC_TYPE_UNKNOWN) {

1412

records.push(recType);

1413

records.push(lastLineNo);

1414

records.push(record);

}

record = [];

recType = type;

lastLineNo = lineNo;

}

var found = false;

switch (recType) {

case REC_TYPE_ACTIVE:

1423

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

caryclark

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

[diff] [blame]

1424

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

caryclark

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

[diff] [blame]

1425

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

caryclark

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

[diff] [blame]

1426

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

caryclark

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

[diff] [blame]

1427

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

caryclark

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

[diff] [blame]

1428

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

caryclark

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

[diff] [blame]

1429

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

caryclark

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

[diff] [blame]

1430

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

caryclark

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

[diff] [blame]

1431

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

caryclark

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

[diff] [blame]

1432

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

1433

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

caryclark

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

[diff] [blame]

1434

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

1435

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

caryclark

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

[diff] [blame]

1436

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

1437

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

caryclark

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

[diff] [blame]

1438

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

1439

);

1440

break;

1441

case REC_TYPE_ACTIVE_OP:

1442

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

1443

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

1448

moveX = record[1][0];

1449

moveY = record[1][1];

1450

found = true;

1451

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

1452

record[1].unshift(moveY);

1453

record[1].unshift(moveX);

1454

moveX = record[1][2];

1455

moveY = record[1][3];

1456

found = true;

1457

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

1458

record[1].unshift(moveY);

1459

record[1].unshift(moveX);

1460

moveX = record[1][4];

1461

moveY = record[1][5];

1462

found = true;

caryclark

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

[diff] [blame]

1463

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

1464

record[1].unshift(moveY);

1465

record[1].unshift(moveX);

1466

moveX = record[1][4];

1467

moveY = record[1][5];

1468

found = true;

caryclark

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

[diff] [blame]

1469

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

1470

record[1].unshift(moveY);

1471

record[1].unshift(moveX);

1472

moveX = record[1][6];

1473

moveY = record[1][7];

1474

found = true;

1475

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

1476

found = true;

1477

} else {

1478

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

1479

}

1480

break;

caryclark

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

[diff] [blame]

1481

case REC_TYPE_AFTERPART:

Cary Clark

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

[diff] [blame]

1482

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

1483

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

1484

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

1485

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

caryclark

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

[diff] [blame]

1486

break;

caryclark

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

[diff] [blame]

1487

case REC_TYPE_ALIGNED:

1488

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

1489

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

1490

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

1491

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

1492

);

1493

break;

caryclark

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

[diff] [blame]

1494

case REC_TYPE_ANGLE:

Cary Clark

59d5a0e

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

[diff] [blame]

1495

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

caryclark

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

[diff] [blame]

1496

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

1501

case REC_TYPE_COINCIDENCE:

1502

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

1503

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

1504

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

1505

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

1506

);

1507

break;

caryclark

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

[diff] [blame]

1508

case REC_TYPE_COMPUTED:

1509

found = line == "computed quadratics given"

1510

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

1511

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

1512

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

caryclark

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

[diff] [blame]

1513

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

caryclark

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

[diff] [blame]

1514

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

1515

);

1516

break;

1517

case REC_TYPE_PATH:

caryclark

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

[diff] [blame]

1518

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

1519

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

caryclark

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

[diff] [blame]

1520

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

caryclark

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

[diff] [blame]

1521

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

1526

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

caryclark

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

[diff] [blame]

1527

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

caryclark

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

[diff] [blame]

1528

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

1533

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

1534

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

1535

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

1536

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

1537

" no intersect LINE_VAL LINE_VAL"

1538

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

1539

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

1540

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

1541

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

1542

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

1543

" no intersect QUAD_VAL LINE_VAL"

1544

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

1545

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

1546

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

1547

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

1548

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

1549

" no intersect QUAD_VAL QUAD_VAL"

caryclark

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

[diff] [blame]

1550

caryclark

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

[diff] [blame]

1551

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

1552

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

1553

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

1554

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

1555

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

1556

" no intersect CONIC_VAL LINE_VAL"

caryclark

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

[diff] [blame]

1557

1558

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

1559

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

1560

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

1561

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

1562

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

1563

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

1564

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

1565

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

1566

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

1567

" no intersect CONIC_VAL QUAD_VAL"

1568

caryclark

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

[diff] [blame]

1569

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

1570

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

1571

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

1572

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

1573

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

1574

" no intersect CONIC_VAL CONIC_VAL"

caryclark

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

[diff] [blame]

1575

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

1576

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

1577

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

1578

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

1579

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

1580

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

1581

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

1582

" no intersect CUBIC_VAL LINE_VAL"

1583

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

1584

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

1585

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

1586

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

1587

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

1588

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

1589

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

1590

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

1591

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

1592

" no intersect CUBIC_VAL QUAD_VAL"

1593

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

1594

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

1595

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

1596

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

1597

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

1598

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

1599

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

1600

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

1601

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

1602

" no intersect CUBIC_VAL CUBIC_VAL"

1603

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

1604

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

1605

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

1606

" no self intersect CUBIC_VAL"

);

break;

case REC_TYPE_SORT:

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

1611

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

1612

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

1613

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

1614

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

1615

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

1616

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

1617

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

1618

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

1619

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

1620

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

1621

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

1622

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

1623

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

1624

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

1625

);

1626

if (found) {

1627

record[1].push(hasDone);

1628

record[1].push(hasUnorderable);

1629

record[1].push(hasSmall);

1630

record[1].push(hasTiny);

1631

record[1].push(hasOperand);

1632

record[1].push(hasStop);

1633

}

1634

break;

caryclark

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

[diff] [blame]

1635

case REC_TYPE_TOP:

1636

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

1637

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

1638

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

1639

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

1640

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

1641

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

1642

);

1643

break;

caryclark

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

[diff] [blame]

1644

case REC_TYPE_MARK:

1645

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

caryclark

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

[diff] [blame]

1646

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

1647

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

caryclark

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

[diff] [blame]

1648

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

1649

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

1650

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

1651

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

caryclark

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

[diff] [blame]

1652

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

1653

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

1654

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

1655

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

1656

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

1657

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

1658

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

1659

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

1660

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

1661

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

1662

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

1663

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

1664

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

1665

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

1666

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

1667

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

1668

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

1669

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

caryclark

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

[diff] [blame]

1670

" last segment=IDX span=IDX"

caryclark

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

[diff] [blame]

1671

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

caryclark

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

[diff] [blame]

1672

" last seg=IDX span=IDX"

1673

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

1674

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

1675

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

1676

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

1677

);

caryclark

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

[diff] [blame]

1678

break;

1679

case REC_TYPE_OP:

1680

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

1681

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

1682

found = true;

1683

break;

1684

}

caryclark

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

[diff] [blame]

1685

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

caryclark

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

[diff] [blame]

1686

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

caryclark

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

[diff] [blame]

1687

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

caryclark

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

[diff] [blame]

1688

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

1689

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

1690

);

1691

break;

1692

case REC_TYPE_UNKNOWN:

found = true;

break;

}

if (!found) {

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

1698

}

1699

}

1700

if (recType != REC_TYPE_UNKNOWN) {

1701

records.push(recType);

1702

records.push(lastLineNo);

1703

records.push(record);

1704

}

1705

if (records.length >= 1) {

1706

tests[testIndex] = records;

1707

testLines[testIndex] = lines;

}

}

function init(test) {

1712

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

1713

if (!canvas.getContext) return;

1714

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

1715

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

1716

var unscaledWidth = window.innerWidth - 20;

1717

var unscaledHeight = window.innerHeight - 20;

1718

screenWidth = unscaledWidth;

1719

screenHeight = unscaledHeight;

1720

canvas.width = unscaledWidth * resScale;

1721

canvas.height = unscaledHeight * resScale;

1722

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

1723

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

1724

if (resScale != 1) {

1725

ctx.scale(resScale, resScale);

}

xmin = Infinity;

xmax = -Infinity;

ymin = Infinity;

ymax = -Infinity;

caryclark

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

[diff] [blame]

1731

hasPath = hasAlignedPath = hasComputedPath = false;

caryclark

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

[diff] [blame]

1732

firstActiveSpan = -1;

1733

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

1734

var recType = test[tIndex];

1735

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

1736

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

1737

throw "stop execution";

1738

}

1739

var records = test[tIndex + 2];

1740

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

1741

var fragType = records[recordIndex];

1742

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

1743

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

1744

throw "stop execution";

1745

}

1746

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]

1752

case REC_TYPE_ALIGNED:

1753

hasAlignedPath = true;

caryclark

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

[diff] [blame]

1754

case REC_TYPE_COMPUTED:

1755

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

1756

break;

1757

}

caryclark

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

[diff] [blame]

1758

if (REC_TYPE_COMPUTED == recType) {

1759

hasComputedPath = true;

1760

}

caryclark

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

[diff] [blame]

1761

case REC_TYPE_PATH:

caryclark

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

[diff] [blame]

1762

first = 1;

caryclark

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

[diff] [blame]

1763

switch (fragType) {

1764

case PATH_LINE:

caryclark

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

[diff] [blame]

1765

last = 5;

caryclark

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

[diff] [blame]

1766

break;

caryclark

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

[diff] [blame]

1767

case PATH_CONIC:

caryclark

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

[diff] [blame]

1768

case PATH_QUAD:

caryclark

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

[diff] [blame]

1769

last = 7;

caryclark

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

[diff] [blame]

1770

break;

1771

case PATH_CUBIC:

caryclark

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

[diff] [blame]

1772

last = 9;

caryclark

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

[diff] [blame]

1773

break;

1774

default:

caryclark

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

[diff] [blame]

1775

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

caryclark

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

[diff] [blame]

1776

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

1777

throw "stop execution";

1778

}

1779

if (recType == REC_TYPE_PATH) {

1780

hasPath = true;

1781

}

1782

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]

1789

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]

1797

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

caryclark

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

[diff] [blame]

1798

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

1799

throw "stop execution";

1800

}

1801

if (recType == REC_TYPE_PATH2) {

1802

hasPath = true;

1803

}

1804

break;

caryclark

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

[diff] [blame]

1805

case REC_TYPE_ACTIVE:

1806

if (firstActiveSpan < 0) {

1807

firstActiveSpan = tIndex;

}

first = 1;

switch (fragType) {

case ACTIVE_LINE_SPAN:

1812

last = 5;

1813

break;

caryclark

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

[diff] [blame]

1814

case ACTIVE_CONIC_SPAN:

caryclark

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

[diff] [blame]

1815

case ACTIVE_QUAD_SPAN:

1816

last = 7;

1817

break;

1818

case ACTIVE_CUBIC_SPAN:

last = 9;

break;

default:

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

1823

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]

1833

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

1845

throw "stop execution";

1846

}

1847

break;

caryclark

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

[diff] [blame]

1848

case REC_TYPE_AFTERPART:

switch (fragType) {

case PATH_LINE:

last = 4;

break;

caryclark

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

[diff] [blame]

1853

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

1862

throw "stop execution";

1863

}

1864

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;

1869

break;

1870

case INTERSECT_LINE_2:

1871

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

1872

break;

1873

case INTERSECT_LINE_NO:

1874

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

1875

break;

caryclark

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

[diff] [blame]

1876

case INTERSECT_CONIC_LINE:

1877

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

1878

break;

caryclark

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

[diff] [blame]

1879

case INTERSECT_QUAD_LINE:

1880

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

1881

break;

caryclark

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

[diff] [blame]

1882

case INTERSECT_CONIC_LINE_2:

1883

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

1884

break;

caryclark

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

[diff] [blame]

1885

case INTERSECT_QUAD_LINE_2:

1886

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

1887

break;

caryclark

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

[diff] [blame]

1888

case INTERSECT_CONIC_LINE_NO:

1889

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

1890

break;

caryclark

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

[diff] [blame]

1891

case INTERSECT_QUAD_LINE_NO:

1892

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

1893

break;

caryclark

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

[diff] [blame]

1894

case INTERSECT_CONIC:

1895

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

1896

break;

caryclark

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

[diff] [blame]

1897

case INTERSECT_QUAD:

1898

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

1899

break;

caryclark

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

[diff] [blame]

1900

case INTERSECT_CONIC_2:

1901

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

1902

break;

caryclark

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

[diff] [blame]

1903

case INTERSECT_QUAD_2:

1904

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

1905

break;

caryclark

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

[diff] [blame]

1906

case INTERSECT_CONIC_NO:

1907

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

1908

break;

caryclark

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

[diff] [blame]

1909

case INTERSECT_QUAD_NO:

1910

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

1911

break;

1912

case INTERSECT_SELF_CUBIC:

1913

first = 1; last = 9;

1914

break;

1915

case INTERSECT_SELF_CUBIC_NO:

1916

first = 0; last = 8;

1917

break;

1918

case INTERSECT_CUBIC_LINE:

1919

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

1920

break;

1921

case INTERSECT_CUBIC_LINE_2:

1922

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

1923

break;

1924

case INTERSECT_CUBIC_LINE_3:

1925

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

1926

break;

1927

case INTERSECT_CUBIC_LINE_NO:

1928

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

1929

break;

caryclark

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

[diff] [blame]

1930

case INTERSECT_CONIC_QUAD:

1931

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

1932

break;

1933

case INTERSECT_CONIC_QUAD_2:

1934

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

1935

break;

caryclark

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

[diff] [blame]

1936

case INTERSECT_CONIC_QUAD_3:

1937

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

1938

break;

1939

case INTERSECT_CONIC_QUAD_4:

1940

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

1941

break;

caryclark

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

[diff] [blame]

1942

case INTERSECT_CONIC_QUAD_NO:

1943

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

1944

break;

caryclark

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

[diff] [blame]

1945

case INTERSECT_CUBIC_QUAD:

1946

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

1947

break;

1948

case INTERSECT_CUBIC_QUAD_2:

1949

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

1950

break;

1951

case INTERSECT_CUBIC_QUAD_3:

1952

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

1953

break;

1954

case INTERSECT_CUBIC_QUAD_4:

1955

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

1956

break;

1957

case INTERSECT_CUBIC_QUAD_NO:

1958

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

1959

break;

1960

case INTERSECT_CUBIC:

1961

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

1962

break;

1963

case INTERSECT_CUBIC_2:

1964

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

1965

break;

1966

case INTERSECT_CUBIC_3:

1967

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

1968

break;

1969

case INTERSECT_CUBIC_4:

1970

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

1971

break;

1972

case INTERSECT_CUBIC_NO:

1973

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

1974

break;

1975

default:

1976

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

1977

throw "stop execution";

}

break;

default:

continue;

}

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

1984

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

1985

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

1986

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

1987

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

1988

}

1989

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

1990

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

1991

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

1992

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

1993

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

}

}

}

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

1998

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

1999

var recType = test[tIndex];

2000

var records = test[tIndex + 2];

2001

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

2002

var fragType = records[recordIndex];

2003

var frags = records[recordIndex + 1];

2004

switch (recType) {

2005

case REC_TYPE_ACTIVE_OP:

if (!draw_op) {

break;

}

{

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

2011

curve_extremes(curve, angleBounds);

}

break;

case REC_TYPE_ANGLE:

if (!draw_angle) {

break;

}

caryclark

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

[diff] [blame]

2018

{

caryclark

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

[diff] [blame]

2019

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

2020

curve_extremes(curve, angleBounds);

2021

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

2022

curve_extremes(curve, angleBounds);

2023

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

2024

}

2025

break;

caryclark

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

[diff] [blame]

2026

case REC_TYPE_COINCIDENCE:

2027

if (!draw_coincidence) {

break;

}

{

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

2032

curve_extremes(curve, angleBounds);

2033

}

2034

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

2040

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

2041

curve_extremes(curve, angleBounds);

2042

}

2043

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

2050

curve_extremes(curve, angleBounds);

2051

}

2052

break;

caryclark

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

[diff] [blame]

}

}

}

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

2057

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

2058

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

2059

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

2060

setScale(xmin, xmax, ymin, ymax);

2061

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

caryclark

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

[diff] [blame]

2062

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

caryclark

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

[diff] [blame]

2063

}

2064

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

draw_computed = 0;

}

}

caryclark

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

[diff] [blame]

2069

function curveByIDMatch(test, id, recMatch) {

caryclark

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

[diff] [blame]

2070

var tIndex = -3;

2071

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

caryclark

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

[diff] [blame]

2072

var recType = test[tIndex];

caryclark

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

[diff] [blame]

2073

if (recType == REC_TYPE_OP) {

2074

continue;

2075

}

caryclark

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

[diff] [blame]

2076

if (recType != recMatch) {

caryclark

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

[diff] [blame]

2077

return [];

2078

}

2079

var records = test[tIndex + 2];

2080

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

2081

var fragType = records[recordIndex];

2082

var frags = records[recordIndex + 1];

2083

if (frags[0] == id) {

2084

switch (fragType) {

caryclark

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

[diff] [blame]

2085

case PATH_LINE:

caryclark

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

[diff] [blame]

2086

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

caryclark

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

[diff] [blame]

2087

case PATH_QUAD:

caryclark

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

[diff] [blame]

2088

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

2089

frags[5], frags[6]];

caryclark

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

[diff] [blame]

2090

case PATH_CONIC:

2091

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

2092

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

caryclark

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

[diff] [blame]

2093

case PATH_CUBIC:

caryclark

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

[diff] [blame]

2094

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

2095

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

2096

}

2097

}

2098

}

caryclark

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

[diff] [blame]

}

return [];

}

caryclark

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

[diff] [blame]

2103

function curveByID(test, id) {

2104

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

2105

if (!result.length) {

2106

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]

2112

var tIndex = -3;

2113

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

caryclark

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

[diff] [blame]

2114

var recType = test[tIndex];

caryclark

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

[diff] [blame]

2115

if (recType == REC_TYPE_OP) {

2116

continue;

2117

}

caryclark

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

[diff] [blame]

2118

if (recType != recMatch) {

caryclark

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

[diff] [blame]

2119

return [];

2120

}

2121

var records = test[tIndex + 2];

2122

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

2123

var fragType = records[recordIndex];

2124

var frags = records[recordIndex + 1];

2125

if (frags[0] == id) {

2126

switch (fragType) {

caryclark

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

[diff] [blame]

2127

case PATH_LINE:

caryclark

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

[diff] [blame]

2128

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

caryclark

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

[diff] [blame]

2129

case PATH_QUAD:

caryclark

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

[diff] [blame]

2130

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

2131

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

caryclark

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

[diff] [blame]

2132

case PATH_CONIC:

2133

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

2134

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

caryclark

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

[diff] [blame]

2135

case PATH_CUBIC:

caryclark

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

[diff] [blame]

2136

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

2137

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

2138

}

2139

}

2140

}

caryclark

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

[diff] [blame]

}

return [];

}

caryclark

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

[diff] [blame]

2145

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

2146

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

2147

if (!result.length) {

2148

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]

2154

var tIndex = 0;

caryclark

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

[diff] [blame]

2155

while (tIndex < test.length) {

2156

var recType = test[tIndex];

caryclark

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

[diff] [blame]

2157

if (recType != recMatch) {

caryclark

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

[diff] [blame]

2158

++tIndex;

2159

continue;

caryclark

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

[diff] [blame]

2160

}

2161

var records = test[tIndex + 2];

2162

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

2163

var fragType = records[recordIndex];

2164

var frags = records[recordIndex + 1];

caryclark

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

[diff] [blame]

2165

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

2166

continue;

2167

}

caryclark

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

[diff] [blame]

2168

switch (fragType) {

caryclark

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

[diff] [blame]

2169

case PATH_LINE:

caryclark

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

[diff] [blame]

2170

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

2171

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

2172

continue;

2173

}

2174

return frags[0];

caryclark

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

[diff] [blame]

2175

case PATH_QUAD:

caryclark

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

[diff] [blame]

2176

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

2177

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

2178

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

2179

continue;

2180

}

2181

return frags[0];

caryclark

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

[diff] [blame]

2182

case PATH_CONIC:

2183

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

2184

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

2185

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

2186

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

2187

continue;

2188

}

2189

return frags[0];

caryclark

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

[diff] [blame]

2190

case PATH_CUBIC:

caryclark

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

[diff] [blame]

2191

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

2192

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

2193

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

2194

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

2205

function idByCurve(test, frag, type) {

2206

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

2207

if (!result.length) {

2208

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

}

return result;

}

caryclark

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

[diff] [blame]

2213

function curve_extremes(curve, bounds) {

caryclark

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

[diff] [blame]

2214

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

caryclark

ed0935a

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

[diff] [blame]

2215

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

caryclark

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

[diff] [blame]

2216

var x = curve[index];

2217

var y = curve[index + 1];

2218

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

2219

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

2220

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

2221

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

}

}

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

2226

var srcWidth = x1 - x0;

2227

var srcHeight = y1 - y0;

2228

var usableWidth = screenWidth;

2229

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

2230

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

2231

usableWidth -= (xDigits + yDigits) * 10;

2232

usableWidth -= decimal_places * 10;

if (draw_legend) {

usableWidth -= 40;

}

var hscale = usableWidth / srcWidth;

2237

var vscale = screenHeight / srcHeight;

2238

scale = Math.min(hscale, vscale);

2239

var invScale = 1 / scale;

2240

var sxmin = x0 - invScale * 5;

2241

var symin = y0 - invScale * 10;

2242

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

2243

var symax = y1 + invScale * 10;

2244

srcWidth = sxmax - sxmin;

2245

srcHeight = symax - symin;

2246

hscale = usableWidth / srcWidth;

2247

vscale = screenHeight / srcHeight;

2248

scale = Math.min(hscale, vscale);

srcLeft = sxmin;

srcTop = symin;

}

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

2254

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

2255

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

2256

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

2257

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

2258

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

2259

var _dist = dist * scale;

2260

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

2261

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

2262

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

var divisor = 4;

var endDist;

do {

var ends = [];

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

2268

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

2269

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

ends.push(px);

ends.push(py);

}

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

2274

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

2275

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

2288

ctx.beginPath();

2289

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

2290

ctx.stroke();

2291

var saveAlign = ctx.textAlign;

2292

var saveStyle = ctx.fillStyle;

2293

var saveFont = ctx.font;

2294

ctx.textAlign = "center";

2295

ctx.fillStyle = "black";

2296

ctx.font = "normal 24px Arial";

2297

divisor *= 0.8;

2298

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

2299

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

2300

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

2301

var _px = (px - srcLeft) * scale;

2302

var _py = (py - srcTop) * scale;

2303

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

2304

}

2305

ctx.textAlign = saveAlign;

2306

ctx.fillStyle = saveStyle;

ctx.font = saveFont;

}

function drawPoint(px, py, end) {

caryclark

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

[diff] [blame]

2311

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

2312

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

caryclark

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

[diff] [blame]

2313

var x = drawnPts[pts];

2314

var y = drawnPts[pts + 1];

2315

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

return;

}

}

drawnPts.push(px);

drawnPts.push(py);

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

2322

var _px = (px - srcLeft) * scale;

2323

var _py = (py - srcTop) * scale;

2324

ctx.beginPath();

2325

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

2334

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

}

}

caryclark

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

[diff] [blame]

2338

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]

2352

function drawPoints(ptArray, curveType, drawControls) {

caryclark

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

[diff] [blame]

2353

var count = coordCount(curveType);

caryclark

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

[diff] [blame]

2354

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

2355

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

2356

continue;

2357

}

2358

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

}

}

function drawControlLines(curve, curveType, drawEnd) {

2363

if (curveType == PATH_LINE) {

2364

return;

2365

}

2366

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

2367

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

2368

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

2369

if (curveType == PATH_CUBIC) {

2370

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

2371

if (drawEnd > 1) {

2372

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

2373

if (drawEnd > 2) {

2374

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

2375

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

2376

}

2377

}

2378

} else if (drawEnd > 1) {

2379

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

2390

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

break;

case PATH_QUAD:

var one_t = 1 - t;

var a = one_t * one_t;

2395

var b = 2 * one_t * t;

2396

var c = t * t;

2397

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

2398

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

2399

break;

caryclark

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

[diff] [blame]

2400

case PATH_CONIC:

2401

var one_t = 1 - t;

2402

var a = one_t * one_t;

2403

var b = 2 * one_t * t;

2404

var c = t * t;

2405

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

2406

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

2407

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

2408

xy.x /= d;

2409

xy.y /= d;

2410

break;

caryclark

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

[diff] [blame]

2411

case PATH_CUBIC:

2412

var one_t = 1 - t;

2413

var one_t2 = one_t * one_t;

2414

var a = one_t2 * one_t;

2415

var b = 3 * one_t2 * t;

2416

var t2 = t * t;

2417

var c = 3 * one_t * t2;

2418

var d = t2 * t;

2419

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

2420

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]

2425

caryclark

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

[diff] [blame]

2426

function drawPointAtT(curve, curveType) {

2427

var x, y;

2428

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

2429

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

2430

if (!draw_intersectT) {

2431

return;

2432

}

2433

ctx.fillStyle = "red";

2434

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

2435

}

2436

2437

function drawTAtPointUp(px, py, t) {

2438

var label = t.toFixed(decimal_places);

2439

var _px = (px - srcLeft)* scale;

2440

var _py = (py - srcTop) * scale;

2441

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

2442

}

2443

2444

function drawTAtPointDown(px, py, t) {

2445

var label = t.toFixed(decimal_places);

2446

var _px = (px - srcLeft)* scale;

2447

var _py = (py - srcTop) * scale;

2448

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

2449

}

2450

2451

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

2452

if (collect_bounds) {

2453

if (focus_enabled) {

2454

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

2455

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

2456

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

2457

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

}

return true;

}

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

2462

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

2463

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

2475

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

return;

}

ctx.beginPath();

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

2480

(y1 - srcTop) * scale);

2481

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

2482

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

2499

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,

2509

(ay - srcTop) * scale);

2510

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

2511

(by - srcTop) * scale);

ctx.stroke();

}

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

2516

if (collect_bounds) {

2517

if (focus_enabled) {

2518

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

2519

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

2520

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

2521

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

}

return true;

}

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

2526

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

2527

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

2528

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

2542

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

return;

}

ctx.beginPath();

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

2547

(y1 - srcTop) * scale);

2548

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

2549

(y2 - srcTop) * scale,

2550

(x3 - srcLeft) * scale,

2551

(y3 - srcTop) * scale);

ctx.stroke();

}

function interp(A, B, t) {

2556

return A + (B - A) * t;

2557

}

2558

2559

function interp_quad_coords(x1, x2, x3, t)

2560

{

2561

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

2562

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

2563

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

return abc;

}

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

2568

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

2569

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

2570

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

2571

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

2572

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

2573

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

2574

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

2575

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

2576

var array = [

2577

ax, ay, bx, by, cx, cy

];

return array;

}

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

2583

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,

2595

(ay - srcTop) * scale);

2596

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

2597

(by - srcTop) * scale,

2598

(cx - srcLeft) * scale,

2599

(cy - srcTop) * scale);

ctx.stroke();

}

caryclark

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

[diff] [blame]

2603

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

2604

if (collect_bounds) {

2605

if (focus_enabled) {

2606

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

2607

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

2608

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

2609

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

}

return true;

}

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

2614

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

caryclark

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

[diff] [blame]

2615

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

2616

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

caryclark

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

[diff] [blame]

2617

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

return true;

}

}

drawnConics.push(x1);

2622

drawnConics.push(y1);

2623

drawnConics.push(x2);

2624

drawnConics.push(y2);

2625

drawnConics.push(x3);

2626

drawnConics.push(y3);

drawnCubics.push(w);

return false;

}

var kMaxConicToQuadPOW2 = 5;

2632

2633

function computeQuadPOW2(curve, tol) {

2634

var a = curve[6] - 1;

2635

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

2636

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

2637

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

2638

2639

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

2640

var pow2;

2641

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

if (error <= tol) {

break;

}

error *= 0.25;

}

return pow2;

}

function subdivide_w_value(w) {

2651

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

2652

}

2653

2654

function chop(curve, part1, part2) {

2655

var w = curve[6];

2656

var scale = 1 / (1 + w);

2657

part1[0] = curve[0];

2658

part1[1] = curve[1];

2659

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

2660

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

2661

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

2662

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

2663

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

2664

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

2665

part2[4] = curve[4];

2666

part2[5] = curve[5];

2667

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

2668

}

2669

2670

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

2678

chop(curve, part1, part2);

2679

--level;

2680

subdivide(part1, level, pts);

2681

subdivide(part2, level, pts);

}

}

function chopIntoQuadsPOW2(curve, pow2, pts) {

2686

subdivide(curve, pow2, pts);

return 1 << pow2;

}

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

2691

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

return;

}

ctx.beginPath();

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

2696

(y1 - srcTop) * scale);

2697

var tol = 1 / scale;

2698

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

2699

var pow2 = computeQuadPOW2(curve, tol);

2700

var pts = [];

2701

chopIntoQuadsPOW2(curve, pow2, pts);

2702

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

2703

ctx.quadraticCurveTo(

2704

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

2705

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

}

ctx.stroke();

}

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

2711

var src2w = x2 * w;

2712

var C = x1;

2713

var A = x3 - 2 * src2w + C;

2714

var B = 2 * (src2w - C);

2715

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;

2724

}

2725

2726

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

2727

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

2728

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

2729

var az = conic_eval_denominator(w, t1);

2730

var midT = (t1 + t2) / 2;

2731

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

2732

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

2733

var dz = conic_eval_denominator(w, midT);

2734

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

2735

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

2736

var cz = conic_eval_denominator(w, t2);

2737

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

2738

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

2739

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

2740

var dt = t2 - t1;

2741

var dt_1 = 1 - dt;

caryclark

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

[diff] [blame]

2742

var array = [

caryclark

ed0935a

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

[diff] [blame]

2743

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

caryclark

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

[diff] [blame]

2744

];

caryclark

ed0935a

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

[diff] [blame]

2745

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

2746

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

2747

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

2748

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

2749

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

2750

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

2751

array[6] = partW;

caryclark

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

[diff] [blame]

2752

return array;

2753

}

caryclark

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

[diff] [blame]

2754

caryclark

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

[diff] [blame]

2755

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

2756

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

2765

}

2766

caryclark

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

[diff] [blame]

2767

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

2768

if (collect_bounds) {

2769

if (focus_enabled) {

2770

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

2771

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

2772

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

2773

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

}

return true;

}

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

2778

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

caryclark

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

[diff] [blame]

2779

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

2780

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

caryclark

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

[diff] [blame]

2781

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

return true;

}

}

drawnCubics.push(x1);

2786

drawnCubics.push(y1);

2787

drawnCubics.push(x2);

2788

drawnCubics.push(y2);

2789

drawnCubics.push(x3);

2790

drawnCubics.push(y3);

2791

drawnCubics.push(x4);

2792

drawnCubics.push(y4);

return false;

}

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

2797

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

return;

}

ctx.beginPath();

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

2802

(y1 - srcTop) * scale);

2803

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

2804

(y2 - srcTop) * scale,

2805

(x3 - srcLeft) * scale,

2806

(y3 - srcTop) * scale,

2807

(x4 - srcLeft) * scale,

2808

(y4 - srcTop) * scale);

ctx.stroke();

}

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

2813

{

2814

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

2815

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

2816

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

2817

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

2818

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

2819

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

return abcd;

}

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

2824

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

2825

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

2826

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

2827

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

2828

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

2829

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

2830

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

2831

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

2832

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

2833

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

2834

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

2835

var ny = fy * 27 - ay - dy * 8;

2836

var bx = (mx * 2 - nx) / 18;

2837

var by = (my * 2 - ny) / 18;

2838

var cx = (nx * 2 - mx) / 18;

2839

var cy = (ny * 2 - my) / 18;

2840

var array = [

2841

ax, ay, bx, by, cx, cy, dx, dy

2842

];

2843

return array;

2844

}

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2845

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2846

function drawCubicPartial(x1, y1, x2, y2, x3, y3, x4, y4, t1, t2) {

2847

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,

2861

(ay - srcTop) * scale);

2862

ctx.bezierCurveTo((bx - srcLeft) * scale,

2863

(by - srcTop) * scale,

2864

(cx - srcLeft) * scale,

2865

(cy - srcTop) * scale,

2866

(dx - srcLeft) * scale,

2867

(dy - srcTop) * scale);

ctx.stroke();

}

function drawCurve(c) {

2872

switch (c.length) {

2873

case 4:

2874

drawLine(c[0], c[1], c[2], c[3]);

2875

break;

2876

case 6:

2877

drawQuad(c[0], c[1], c[2], c[3], c[4], c[5]);

2878

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2879

case 7:

2880

drawConicWithQuads(c[0], c[1], c[2], c[3], c[4], c[5], c[6]);

2881

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2882

case 8:

2883

drawCubic(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]);

break;

}

}

function boundsWidth(pts) {

2889

var min = pts[0];

2890

var max = pts[0];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2891

var length = pts.length == 7 ? 6 : pts.length;

2892

for (var idx = 2; idx < length; idx += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2893

min = Math.min(min, pts[idx]);

2894

max = Math.max(max, pts[idx]);

}

return max - min;

}

function boundsHeight(pts) {

2900

var min = pts[1];

2901

var max = pts[1];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2902

var length = pts.length == 7 ? 6 : pts.length;

2903

for (var idx = 3; idx < length; idx += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2904

min = Math.min(min, pts[idx]);

2905

max = Math.max(max, pts[idx]);

}

return max - min;

}

function tangent(pts) {

2911

var dx = pts[2] - pts[0];

2912

var dy = pts[3] - pts[1];

2913

if (dx == 0 && dy == 0 && pts.length > 4) {

2914

dx = pts[4] - pts[0];

2915

dy = pts[5] - pts[1];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2916

if (dx == 0 && dy == 0 && pts.length == 8) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2917

dx = pts[6] - pts[0];

2918

dy = pts[7] - pts[1];

2919

}

2920

}

2921

return Math.atan2(-dy, dx);

2922

}

2923

2924

function hodograph(cubic) {

2925

var hodo = [];

2926

hodo[0] = 3 * (cubic[2] - cubic[0]);

2927

hodo[1] = 3 * (cubic[3] - cubic[1]);

2928

hodo[2] = 3 * (cubic[4] - cubic[2]);

2929

hodo[3] = 3 * (cubic[5] - cubic[3]);

2930

hodo[4] = 3 * (cubic[6] - cubic[4]);

2931

hodo[5] = 3 * (cubic[7] - cubic[5]);

return hodo;

}

function hodograph2(cubic) {

2936

var quad = hodograph(cubic);

2937

var hodo = [];

2938

hodo[0] = 2 * (quad[2] - quad[0]);

2939

hodo[1] = 2 * (quad[3] - quad[1]);

2940

hodo[2] = 2 * (quad[4] - quad[2]);

2941

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];

2968

}

2969

2970

function add_valid_ts(s, realRoots, t) {

2971

var foundRoots = 0;

2972

for (var index = 0; index < realRoots; ++index) {

2973

var tValue = s[index];

2974

if (tValue >= 0 && tValue <= 1) {

2975

for (var idx2 = 0; idx2 < foundRoots; ++idx2) {

2976

if (t[idx2] != tValue) {

2977

t[foundRoots++] = tValue;

}

}

}

}

return foundRoots;

}

function quadraticRootsValidT(a, b, c, t) {

2986

var s = [];

2987

var realRoots = quadraticRootsReal(A, B, C, s);

2988

var foundRoots = add_valid_ts(s, realRoots, t);

2989

return foundRoots != 0;

2990

}

2991

2992

function find_cubic_inflections(cubic, tValues) {

2993

var Ax = src[2] - src[0];

2994

var Ay = src[3] - src[1];

2995

var Bx = src[4] - 2 * src[2] + src[0];

2996

var By = src[5] - 2 * src[3] + src[1];

2997

var Cx = src[6] + 3 * (src[2] - src[4]) - src[0];

2998

var Cy = src[7] + 3 * (src[3] - src[5]) - src[1];

2999

return quadraticRootsValidT(Bx * Cy - By * Cx, (Ax * Cy - Ay * Cx),

3000

Ax * By - Ay * Bx, tValues);

3001

}

3002

3003

function dxy_at_t(curve, type, t) {

3004

var dxy = {};

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3005

if (type == PATH_LINE) {

3006

dxy.x = curve[2] - curve[0];

3007

dxy.y = curve[3] - curve[1];

3008

} else if (type == PATH_QUAD) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

var a = t - 1;

var b = 1 - 2 * t;

var c = t;

dxy.x = a * curve[0] + b * curve[2] + c * curve[4];

3013

dxy.y = a * curve[1] + b * curve[3] + c * curve[5];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3014

} else if (type == PATH_CONIC) {

3015

var p20x = curve[4] - curve[0];

3016

var p20y = curve[5] - curve[1];

3017

var p10xw = (curve[2] - curve[0]) * curve[6];

3018

var p10yw = (curve[3] - curve[1]) * curve[6];

3019

var coeff0x = curve[6] * p20x - p20x;

3020

var coeff0y = curve[6] * p20y - p20y;

3021

var coeff1x = p20x - 2 * p10xw;

3022

var coeff1y = p20y - 2 * p10yw;

3023

dxy.x = t * (t * coeff0x + coeff1x) + p10xw;

3024

dxy.y = t * (t * coeff0y + coeff1y) + p10yw;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3025

} else if (type == PATH_CUBIC) {

var one_t = 1 - t;

var a = curve[0];

var b = curve[2];

var c = curve[4];

var d = curve[6];

dxy.x = 3 * ((b - a) * one_t * one_t + 2 * (c - b) * t * one_t + (d - c) * t * t);

a = curve[1];

b = curve[3];

c = curve[5];

d = curve[7];

dxy.y = 3 * ((b - a) * one_t * one_t + 2 * (c - b) * t * one_t + (d - c) * t * t);

}

return dxy;

}

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3041

function dpt_at_t(curve, t) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3042

var type = PATH_LINE + (curve.length / 2 - 2);

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3043

return dxy_at_t(curve, type, t);

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3044

}

3045

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3046

function drawLabel(num, px, py) {

3047

ctx.beginPath();

3048

ctx.arc(px, py, 8, 0, Math.PI*2, true);

3049

ctx.closePath();

3050

ctx.strokeStyle = "rgba(0,0,0, 0.4)";

3051

ctx.lineWidth = num == 0 || num == 3 ? 2 : 1;

3052

ctx.stroke();

3053

ctx.fillStyle = "black";

3054

ctx.font = "normal 10px Arial";

3055

// ctx.rotate(0.001);

3056

ctx.fillText(num, px - 2, py + 3);

3057

// ctx.rotate(-0.001);

3058

}

3059

3060

function drawLabelX(ymin, num, loc) {

3061

var px = (loc - srcLeft) * scale;

3062

var py = (ymin - srcTop) * scale - 20;

3063

drawLabel(num, px, py);

3064

}

3065

3066

function drawLabelY(xmin, num, loc) {

3067

var px = (xmin - srcLeft) * scale - 20;

3068

var py = (loc - srcTop) * scale;

3069

drawLabel(num, px, py);

3070

}

3071

3072

function drawHodoOrigin(hx, hy, hMinX, hMinY, hMaxX, hMaxY) {

3073

ctx.beginPath();

3074

ctx.moveTo(hx, hy - 100);

3075

ctx.lineTo(hx, hy);

3076

ctx.strokeStyle = hMinY < 0 ? "green" : "blue";

ctx.stroke();

ctx.beginPath();

ctx.moveTo(hx, hy);

ctx.lineTo(hx, hy + 100);

3081

ctx.strokeStyle = hMaxY > 0 ? "green" : "blue";

3082

ctx.stroke();

3083

ctx.beginPath();

3084

ctx.moveTo(hx - 100, hy);

3085

ctx.lineTo(hx, hy);

3086

ctx.strokeStyle = hMinX < 0 ? "green" : "blue";

ctx.stroke();

ctx.beginPath();

ctx.moveTo(hx, hy);

ctx.lineTo(hx + 100, hy);

3091

ctx.strokeStyle = hMaxX > 0 ? "green" : "blue";

ctx.stroke();

}

function scalexy(x, y, mag) {

3096

var length = Math.sqrt(x * x + y * y);

return mag / length;

}

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3100

function drawArrow(x, y, dx, dy, s) {

3101

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);

3106

x += dx;

3107

y += dy;

3108

ctx.lineTo((x - srcLeft) * scale, (y - srcTop) * scale);

3109

dx /= 10;

3110

dy /= 10;

3111

ctx.lineTo((x - dy - srcLeft) * scale, (y + dx - srcTop) * scale);

3112

ctx.lineTo((x + dx * 2 - srcLeft) * scale, (y + dy * 2 - srcTop) * scale);

3113

ctx.lineTo((x + dy - srcLeft) * scale, (y - dx - srcTop) * scale);

3114

ctx.lineTo((x - srcLeft) * scale, (y - srcTop) * scale);

3115

ctx.strokeStyle = "rgba(0,75,0, 0.4)";

ctx.stroke();

}

function x_at_t(curve, t) {

3120

var one_t = 1 - t;

3121

if (curve.length == 4) {

3122

return one_t * curve[0] + t * curve[2];

3123

}

3124

var one_t2 = one_t * one_t;

3125

var t2 = t * t;

3126

if (curve.length == 6) {

3127

return one_t2 * curve[0] + 2 * one_t * t * curve[2] + t2 * curve[4];

3128

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3129

if (curve.length == 7) {

3130

return (one_t2 * curve[0] + 2 * one_t * t * curve[2] * curve[6] + t2 * curve[4])

3131

/ (one_t2 +2 * one_t * t * curve[6] + t2);

3132

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3133

var a = one_t2 * one_t;

3134

var b = 3 * one_t2 * t;

3135

var c = 3 * one_t * t2;

3136

var d = t2 * t;

3137

return a * curve[0] + b * curve[2] + c * curve[4] + d * curve[6];

3138

}

3139

3140

function y_at_t(curve, t) {

3141

var one_t = 1 - t;

3142

if (curve.length == 4) {

3143

return one_t * curve[1] + t * curve[3];

3144

}

3145

var one_t2 = one_t * one_t;

3146

var t2 = t * t;

3147

if (curve.length == 6) {

3148

return one_t2 * curve[1] + 2 * one_t * t * curve[3] + t2 * curve[5];

3149

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3150

if (curve.length == 7) {

3151

return (one_t2 * curve[1] + 2 * one_t * t * curve[3] * curve[6] + t2 * curve[5])

3152

/ (one_t2 +2 * one_t * t * curve[6] + t2);

3153

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3154

var a = one_t2 * one_t;

3155

var b = 3 * one_t2 * t;

3156

var c = 3 * one_t * t2;

3157

var d = t2 * t;

3158

return a * curve[1] + b * curve[3] + c * curve[5] + d * curve[7];

3159

}

3160

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3161

function pt_at_t(curve, t) {

3162

var pt = {};

3163

pt.x = x_at_t(curve, t);

3164

pt.y = y_at_t(curve, t);

3165

return pt;

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3166

}

3167

3168

function drawOrder(curve, t, label) {

3169

var px = x_at_t(curve, t);

3170

var py = y_at_t(curve, t);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3171

var _px = (px - srcLeft) * scale;

3172

var _py = (py - srcTop) * scale;

3173

ctx.beginPath();

3174

ctx.arc(_px, _py, 15, 0, Math.PI * 2, true);

3175

ctx.closePath();

3176

ctx.fillStyle = "white";

3177

ctx.fill();

3178

if (label == 'L') {

3179

ctx.strokeStyle = "rgba(255,0,0, 1)";

3180

ctx.fillStyle = "rgba(255,0,0, 1)";

3181

} else {

3182

ctx.strokeStyle = "rgba(0,0,255, 1)";

3183

ctx.fillStyle = "rgba(0,0,255, 1)";

3184

}

3185

ctx.stroke();

3186

ctx.font = "normal 16px Arial";

3187

ctx.textAlign = "center";

3188

ctx.fillText(label, _px, _py + 5);

3189

ctx.font = "normal 10px Arial";

3190

}

3191

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3192

function drawVisibleOrder(curve, label) {

3193

var s = pt_at_t(curve, 0);

3194

var e = pt_at_t(curve, 1);

3195

var sOn = ptOnScreen(s);

3196

var eOn = ptOnScreen(e);

3197

var defaultT = 0.85;

3198

if (sOn && eOn)

3199

return drawOrder(curve, defaultT, label);

3200

if (sOn || eOn) {

3201

if (eOn) {

3202

defaultT = 1 - defaultT;

3203

}

3204

var step = sOn ? -defaultT / 2 : (1 - defaultT) / 2;

var t = defaultT;

var tries = 16;

do {

var mid = pt_at_t(curve, t);

3209

if (ptOnScreen(mid))

3210

return drawOrder(curve, t, label);

3211

t += step;

3212

step /= 2;

3213

} while (--tries > 0);

3214

drawOrder(curve, defaultT, label);

3215

}

3216

// scattershot until we find a visible point

3217

var denom = 2; // visit odd number num / denom to hit unique pts

3218

var tries = 6; // tries 1/2, 1/4, 3/4, 1/8, 3/8, 5/8, 7/8, 1/16 ...

3219

do {

3220

for (var numer = 1; numer < denom; numer += 2) {

3221

var t = numer / denom + 0.1;

if (t >= 1) {

break;

}

var mid = pt_at_t(curve, t);

3226

if (ptOnScreen(mid))

3227

return drawOrder(curve, t, label);

3228

}

3229

denom *= 2;

3230

} while (--tries > 0);

3231

drawOrder(curve, defaultT, label);

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3232

}

3233

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3234

function set_length(pt, newLen) {

3235

var len = Math.sqrt(pt.x * pt.x + pt.y * pt.y);

3236

var scale = newLen / len;

3237

var newPt = { x: pt.x * scale, y: pt.y * scale };

3238

return newPt;

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3239

}

3240

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3241

function drawDirection(curve, t) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3242

var d = dpt_at_t(curve, t);

3243

d = set_length(d, 16);

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3244

var pt = localToGlobal(pt_at_t(curve, t));

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3245

ctx.beginPath();

3246

ctx.moveTo(pt.x - d.y, pt.y + d.x);

3247

ctx.lineTo(pt.x + d.x, pt.y + d.y);

3248

ctx.lineTo(pt.x + d.y, pt.y - d.x);

3249

ctx.strokeStyle = "rgba(0,75,0, 0.4)";

ctx.stroke();

}

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3253

function drawVisibleDirection(curve) {

3254

var s = pt_at_t(curve, 0);

3255

var e = pt_at_t(curve, 1);

3256

var sOn = ptOnScreen(s);

3257

var eOn = ptOnScreen(e);

3258

var defaultT = 0.65;

3259

if (sOn && eOn) {

3260

return drawDirection(curve, defaultT);

}

if (sOn || eOn) {

if (eOn) {

defaultT = 1 - defaultT;

3265

}

3266

var step = sOn ? -defaultT / 2 : (1 - defaultT) / 2;

var t = defaultT;

var tries = 16;

do {

var mid = pt_at_t(curve, t);

3271

if (ptOnScreen(mid))

3272

return drawDirection(curve, t);

3273

t += step;

3274

step /= 2;

3275

} while (--tries > 0);

3276

drawDirection(curve, defaultT);

3277

}

3278

// scattershot until we find a visible point

3279

var denom = 2; // visit odd number num / denom to hit unique pts

3280

var tries = 6; // tries 1/2, 1/4, 3/4, 1/8, 3/8, 5/8, 7/8, 1/16 ...

3281

do {

3282

for (var numer = 1; numer < denom; numer += 2) {

3283

var t = numer / denom + 0.1;

if (t >= 1) {

break;

}

var mid = pt_at_t(curve, t);

3288

if (ptOnScreen(mid))

3289

return drawDirection(curve, t);

3290

}

3291

denom *= 2;

3292

} while (--tries > 0);

3293

drawDirection(curve, defaultT);

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3294

}

3295

3296

function drawID(curve, t, id) {

3297

var px = x_at_t(curve, t);

3298

var py = y_at_t(curve, t);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3299

var _px = (px - srcLeft) * scale;

3300

var _py = (py - srcTop) * scale;

3301

draw_id_at(id, _px, _py);

3302

}

3303

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3304

function localToGlobal(local) {

3305

var global = {};

3306

global.x = (local.x - srcLeft) * scale;

3307

global.y = (local.y - srcTop) * scale;

3308

return global;

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3309

}

3310

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3311

function ptOnScreen(local) {

3312

var pt = localToGlobal(local);

3313

return 10 <= pt.x && pt.x <= screenWidth - 10

3314

&& 10 <= pt.y && pt.y <= screenHeight - 10;

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3315

}

3316

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3317

function drawVisibleID(curve, defaultT, id) {

3318

// determine if either or both ends are visible

3319

var s = pt_at_t(curve, 0);

3320

var e = pt_at_t(curve, 1);

3321

var sOn = ptOnScreen(s);

3322

var eOn = ptOnScreen(e);

3323

if (sOn && eOn)

3324

return drawID(curve, defaultT, id);

3325

if (sOn || eOn) {

3326

var step = sOn ? -defaultT / 2 : (1 - defaultT) / 2;

var t = defaultT;

var tries = 16;

do {

var mid = pt_at_t(curve, t);

3331

if (ptOnScreen(mid))

3332

return drawID(curve, t, id);

3333

t += step;

3334

step /= 2;

3335

} while (--tries > 0);

3336

drawID(curve, defaultT, id);

3337

}

3338

// scattershot until we find a visible point

3339

var denom = 2; // visit odd number num / denom to hit unique pts

3340

var tries = 6; // tries 1/2, 1/4, 3/4, 1/8, 3/8, 5/8, 7/8, 1/16 ...

3341

do {

3342

for (var numer = 1; numer < denom; numer += 2) {

3343

var t = numer / denom;

3344

var mid = pt_at_t(curve, t);

3345

if (ptOnScreen(mid))

3346

return drawID(curve, t, id);

3347

}

3348

denom *= 2;

3349

} while (--tries > 0);

3350

drawID(curve, defaultT, id);

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3351

}

3352

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3353

function draw_id_at(id, _px, _py) {

3354

ctx.beginPath();

3355

ctx.arc(_px, _py, 15, 0, Math.PI * 2, true);

3356

ctx.closePath();

3357

ctx.fillStyle = "white";

3358

ctx.fill();

3359

ctx.strokeStyle = "rgba(127,127,0, 1)";

3360

ctx.fillStyle = "rgba(127,127,0, 1)";

3361

ctx.stroke();

3362

ctx.font = "normal 16px Arial";

3363

ctx.textAlign = "center";

3364

ctx.fillText(id, _px, _py + 5);

3365

ctx.font = "normal 10px Arial";

3366

}

3367

3368

function drawLinePartialID(id, x1, y1, x2, y2, t1, t2) {

3369

var curve = [x1, y1, x2, y2];

3370

drawCurvePartialID(id, curve, t1, t2);

3371

}

3372

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3373

function drawLineID(id, x1, y1, x2, y2) {

3374

drawLinePartialID(id, x1, y1, x2, y2, 0, 1);

3375

}

3376

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3377

function drawQuadPartialID(id, x1, y1, x2, y2, x3, y3, t1, t2) {

3378

var curve = [x1, y1, x2, y2, x3, y3];

3379

drawCurvePartialID(id, curve, t1, t2);

3380

}

3381

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3382

function drawQuadID(id, x1, y1, x2, y2, x3, y3) {

3383

drawQuadPartialID(id, x1, y1, x2, y2, x3, y3, 0, 1);

3384

}

3385

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3386

function drawConicPartialID(id, x1, y1, x2, y2, x3, y3, w, t1, t2) {

3387

var curve = [x1, y1, x2, y2, x3, y3, w];

3388

drawCurvePartialID(id, curve, t1, t2);

3389

}

3390

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3391

function drawConicID(id, x1, y1, x2, y2, x3, y3, w) {

3392

drawConicPartialID(id, x1, y1, x2, y2, x3, y3, w, 0, 1);

3393

}

3394

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3395

function drawCubicPartialID(id, x1, y1, x2, y2, x3, y3, x4, y4, t1, t2) {

3396

var curve = [x1, y1, x2, y2, x3, y3, x4, y4];

3397

drawCurvePartialID(id, curve, t1, t2);

3398

}

3399

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3400

function drawCubicID(id, x1, y1, x2, y2, x3, y3, x4, y4) {

3401

drawCubicPartialID(id, x1, y1, x2, y2, x3, y3, x4, y4, 0, 1);

3402

}

3403

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3404

function drawCurvePartialID(id, curve, t1, t2) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3405

drawVisibleID(curve, (t1 + t2) / 2, id);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3406

}

3407

3408

function drawCurveSpecials(test, curve, type) {

3409

if (pt_labels) {

3410

drawPoints(curve, type, pt_labels == 2);

3411

}

3412

if (control_lines != 0) {

3413

drawControlLines(curve, type, control_lines);

3414

}

3415

if (curve_t) {

3416

drawPointAtT(curve, type);

3417

}

3418

if (draw_midpoint) {

3419

var mid = pointAtT(curve, type, 0.5);

3420

drawPoint(mid.x, mid.y, true);

3421

}

3422

if (draw_id) {

3423

var id = idByCurve(test, curve, type);

3424

if (id >= 0) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3425

drawVisibleID(curve, 0.5, id);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3426

}

3427

}

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

3428

if (draw_direction) {

3429

drawVisibleDirection(curve);

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

3430

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3431

if (type == PATH_LINE) {

3432

return;

3433

}

3434

if (draw_deriviatives > 0) {

3435

var d = dxy_at_t(curve, type, 0);

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3436

drawArrow(curve[0], curve[1], d.x, d.y, 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3437

if (draw_deriviatives == 2) {

3438

d = dxy_at_t(curve, type, 1);

3439

if (type == PATH_CUBIC) {

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3440

drawArrow(curve[6], curve[7], d.x, d.y, 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3441

} else {

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3442

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);

3447

d = dxy_at_t(curve, type, 0.5);

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3448

drawArrow(mid.x, mid.y, d.x, d.y, 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3449

}

3450

}

3451

if (type != PATH_CUBIC) {

3452

return;

3453

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3454

if (draw_sequence) {

3455

var ymin = Math.min(curve[1], curve[3], curve[5], curve[7]);

3456

for (var i = 0; i < 8; i+= 2) {

3457

drawLabelX(ymin, i >> 1, curve[i]);

3458

}

3459

var xmin = Math.min(curve[0], curve[2], curve[4], curve[6]);

3460

for (var i = 1; i < 8; i+= 2) {

3461

drawLabelY(xmin, i >> 1, curve[i]);

}

}

}

function logCurves(test) {

3467

for (curves in test) {

3468

var curve = test[curves];

dumpCurve(curve);

}

}

function curveToString(curve) {

3474

var str = "{{";

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3475

var length = curve.length == 7 ? 6 : curve.length;

3476

if (curve.length == 7) {

3477

str += "{";

3478

}

3479

for (i = 0; i < length; i += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3480

str += curve[i].toFixed(decimal_places) + "," + curve[i + 1].toFixed(decimal_places);

3481

if (i < curve.length - 2) {

3482

str += "}, {";

3483

}

3484

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3485

str += "}";

3486

if (curve.length == 7) {

3487

str += "}, " + curve[6].toFixed(decimal_places);

3488

}

3489

str += "}";

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

return str;

}

function dumpCurve(curve) {

3494

console.log(curveToString(curve));

3495

}

3496

3497

function draw(test, lines, title) {

3498

ctx.fillStyle = "rgba(0,0,0, 0.1)";

3499

ctx.font = "normal 50px Arial";

3500

ctx.textAlign = "left";

3501

ctx.fillText(title, 50, 50);

3502

ctx.font = "normal 10px Arial";

3503

ctx.lineWidth = "1.001"; "0.999";

3504

var secondPath = test.length;

var closeCount = 0;

logStart = -1;

logRange = 0;

// find last active rec type at this step

3509

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]

3514

var lastCoin = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3515

var lastSect = 0;

3516

var lastSort = 0;

3517

var lastMark = 0;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3518

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]

3525

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]

3530

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]

3535

topMax = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3536

markMax = 0;

3537

lastIndex = test.length - 3;

3538

for (var tIndex = 0; tIndex < test.length; tIndex += 3) {

3539

var recType = test[tIndex];

3540

if (!typeof recType == 'number' || recType < REC_TYPE_UNKNOWN || recType > REC_TYPE_LAST) {

3541

console.log("unknown rec type: " + recType);

3542

throw "stop execution";

3543

}

3544

// if (curType == recType && curType != REC_TYPE_ADD) {

3545

// continue;

3546

// }

3547

var inStepRange = step_limit == 0 || curStep < step_limit;

3548

curType = recType;

3549

if (recType == REC_TYPE_OP) {

hasOp = true;

continue;

}

if (recType == REC_TYPE_UNKNOWN) {

3554

// these types do not advance step

3555

continue;

3556

}

3557

var bumpStep = false;

3558

var records = test[tIndex + 2];

3559

var fragType = records[0];

3560

if (recType == REC_TYPE_ADD) {

3561

if (records.length != 2) {

3562

console.log("expect only two elements: " + records.length);

3563

throw "stop execution";

3564

}

3565

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) {

3577

secondPath = tIndex;

3578

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3579

if (recType == REC_TYPE_PATH2 && hasOp) {

3580

secondPath = tIndex;

3581

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3582

if (recType == REC_TYPE_ACTIVE) {

3583

++activeMax;

3584

if (!draw_active || !inStepRange) {

continue;

}

lastActive = tIndex;

++activeCount;

bumpStep = true;

}

if (recType == REC_TYPE_ACTIVE_OP) {

3592

++opMax;

3593

if (!draw_op || !inStepRange) {

continue;

}

lastOp = tIndex;

++opCount;

bumpStep = true;

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3600

if (recType == REC_TYPE_AFTERPART) {

3601

if (draw_angle != 3 || !inStepRange) {

continue;

}

lastAngle = tIndex;

++angleCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3608

if (recType == REC_TYPE_ANGLE) {

3609

++angleMax;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3610

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]

3617

if (recType == REC_TYPE_COINCIDENCE) {

3618

++coinMax;

3619

if (!draw_coincidence || !inStepRange) {

continue;

}

lastCoin = tIndex;

++coinCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3626

if (recType == REC_TYPE_SECT) {

3627

if (records.length != 2) {

3628

console.log("expect only two elements: " + records.length);

3629

throw "stop execution";

}

++sectMax;

var sectBump = 1;

switch (fragType) {

case INTERSECT_LINE:

case INTERSECT_QUAD_LINE:

3636

case INTERSECT_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3637

case INTERSECT_CONIC_LINE:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3638

case INTERSECT_CONIC_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3639

case INTERSECT_CONIC:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3640

case INTERSECT_SELF_CUBIC:

3641

case INTERSECT_CUBIC_LINE:

3642

case INTERSECT_CUBIC_QUAD:

3643

case INTERSECT_CUBIC:

3644

sectBump = 1;

3645

break;

3646

case INTERSECT_LINE_2:

3647

case INTERSECT_QUAD_LINE_2:

3648

case INTERSECT_QUAD_2:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3649

case INTERSECT_CONIC_LINE_2:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3650

case INTERSECT_CONIC_QUAD_2:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3651

case INTERSECT_CONIC_2:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3652

case INTERSECT_CUBIC_LINE_2:

3653

case INTERSECT_CUBIC_QUAD_2:

3654

case INTERSECT_CUBIC_2:

3655

sectBump = 2;

3656

break;

3657

case INTERSECT_LINE_NO:

3658

case INTERSECT_QUAD_LINE_NO:

3659

case INTERSECT_QUAD_NO:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3660

case INTERSECT_CONIC_LINE_NO:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3661

case INTERSECT_CONIC_QUAD_NO:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3662

case INTERSECT_CONIC_NO:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3663

case INTERSECT_SELF_CUBIC_NO:

3664

case INTERSECT_CUBIC_LINE_NO:

3665

case INTERSECT_CUBIC_QUAD_NO:

3666

case INTERSECT_CUBIC_NO:

3667

sectBump = 0;

3668

break;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

3669

case INTERSECT_CONIC_QUAD_3:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3670

case INTERSECT_CUBIC_LINE_3:

3671

case INTERSECT_CUBIC_QUAD_3:

3672

case INTERSECT_CUBIC_3:

3673

sectBump = 3;

3674

break;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

3675

case INTERSECT_CONIC_QUAD_4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3676

case INTERSECT_CUBIC_QUAD_4:

3677

case INTERSECT_CUBIC_4:

sectBump = 4;

break;

default:

console.log("missing case " + records.length);

3682

throw "stop execution";

3683

}

3684

sectMax2 += sectBump;

3685

if (draw_intersection <= 1 || !inStepRange) {

continue;

}

lastSect = tIndex;

sectCount += sectBump;

3690

bumpStep = true;

3691

}

3692

if (recType == REC_TYPE_SORT) {

3693

++sortMax;

3694

if (!draw_sort || !inStepRange) {

continue;

}

lastSort = tIndex;

++sortCount;

bumpStep = true;

}

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3701

if (recType == REC_TYPE_TOP) {

3702

++topMax;

3703

if (!draw_top || !inStepRange) {

continue;

}

lastTop = tIndex;

++topCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3710

if (recType == REC_TYPE_MARK) {

3711

++markMax;

3712

if (!draw_mark || !inStepRange) {

continue;

}

lastMark = tIndex;

++markCount;

bumpStep = true;

}

if (bumpStep) {

lastIndex = tIndex;

logStart = test[tIndex + 1];

3722

logRange = records.length / 2;

++curStep;

}

}

stepMax = (draw_add ? addMax : 0)

3727

+ (draw_active ? activeMax : 0)

reed

0dc4dd6

2015-03-24 13:55:33 -0700

[diff] [blame]

3728

+ (draw_angle ? angleMax : 0)

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3729

+ (draw_coincidence ? coinMax : 0)

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3730

+ (draw_op ? opMax : 0)

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3731

+ (draw_sort ? sortMax : 0)

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3732

+ (draw_top ? topMax : 0)

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3733

+ (draw_mark ? markMax : 0)

3734

+ (draw_intersection == 2 ? sectMax : draw_intersection == 3 ? sectMax2 : 0);

3735

if (stepMax == 0) {

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3736

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]

3741

drawnConics = [];

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3742

drawnCubics = [];

3743

focusXmin = focusYmin = Infinity;

3744

focusXmax = focusYmax = -Infinity;

3745

var pathIndex = 0;

3746

var opLetter = 'S';

3747

for (var tIndex = lastIndex; tIndex >= 0; tIndex -= 3) {

3748

var recType = test[tIndex];

3749

var records = test[tIndex + 2];

3750

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

3751

var fragType = records[recordIndex];

3752

if (!typeof fragType == 'number' || fragType < 1 || fragType > FRAG_TYPE_LAST) {

3753

console.log("unknown in range frag type: " + fragType);

3754

throw "stop execution";

3755

}

3756

var frags = records[recordIndex + 1];

3757

focus_enabled = false;

3758

switch (recType) {

3759

case REC_TYPE_COMPUTED:

3760

if (draw_computed == 0) {

continue;

}

ctx.lineWidth = 1;

ctx.strokeStyle = pathIndex == 0 ? "black" : "red";

3765

ctx.fillStyle = "blue";

3766

var drawThis = false;

3767

switch (fragType) {

3768

case PATH_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3769

if ((draw_computed & 0x9) == 1 || ((draw_computed & 8) != 0

3770

&& (draw_computed & 7) == pathIndex)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3771

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]

3776

case PATH_CONIC:

3777

if ((draw_computed & 0xA) == 2 || ((draw_computed & 8) != 0

3778

&& (draw_computed & 7) == pathIndex)) {

3779

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

3780

frags[4], frags[5], frags[6]);

3781

drawThis = true;

3782

}

3783

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3784

case PATH_CUBIC:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3785

if ((draw_computed & 0xC) == 4 || ((draw_computed & 8) != 0

3786

&& (draw_computed & 7) == pathIndex)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3787

drawCubic(frags[0], frags[1], frags[2], frags[3],

3788

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);

3801

throw "stop execution";

3802

}

3803

if (!drawThis || collect_bounds) {

3804

break;

3805

}

3806

drawCurveSpecials(test, frags, fragType);

3807

break;

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3808

case REC_TYPE_ALIGNED:

3809

if (draw_path < 4) {

3810

continue;

3811

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3812

case REC_TYPE_PATH:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3813

case REC_TYPE_PATH2:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3814

if (REC_TYPE_ALIGNED != recType && draw_path >= 4) {

3815

continue;

3816

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

if (!draw_path) {

continue;

}

var firstPath = tIndex < secondPath;

3821

if ((draw_path & (firstPath ? 1 : 2)) == 0) {

continue;

}

ctx.lineWidth = 1;

ctx.strokeStyle = firstPath ? "black" : "red";

3826

ctx.fillStyle = "blue";

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3827

var frags2 = [];

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3828

switch (fragType) {

3829

case PATH_LINE:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3830

for (var i = 0; i < 4; ++ i) { frags2[i] = frags[i + 1]; }

3831

drawLine(frags2[0], frags2[1], frags2[2], frags2[3]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3832

break;

3833

case PATH_QUAD:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3834

for (var i = 0; i < 6; ++ i) { frags2[i] = frags[i + 1]; }

3835

drawQuad(frags2[0], frags2[1], frags2[2], frags2[3],

3836

frags2[4], frags2[5]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3837

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3838

case PATH_CONIC:

3839

for (var i = 0; i < 7; ++ i) { frags2[i] = frags[i + 1]; }

3840

drawConicWithQuads(frags2[0], frags2[1], frags2[2], frags2[3],

3841

frags2[4], frags2[5], frags2[6]);

3842

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3843

case PATH_CUBIC:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3844

for (var i = 0; i < 8; ++ i) { frags2[i] = frags[i + 1]; }

3845

drawCubic(frags2[0], frags2[1], frags2[2], frags2[3],

3846

frags2[4], frags2[5], frags2[6], frags2[7]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3847

break;

3848

default:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3849

console.log("unknown " + recType + " frag type: " + fragType);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3850

throw "stop execution";

3851

}

3852

if (collect_bounds) {

3853

break;

3854

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3855

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;

3860

case OP_DIFFERENCE: opLetter = 'D'; break;

3861

case OP_UNION: opLetter = 'U'; break;

3862

case OP_XOR: opLetter = 'X'; break;

3863

default:

3864

console.log("unknown REC_TYPE_OP frag type: " + fragType);

3865

throw "stop execution";

3866

}

3867

break;

3868

case REC_TYPE_ACTIVE:

3869

if (!draw_active || (step_limit > 0 && tIndex < lastActive)) {

3870

continue;

3871

}

3872

var x1 = frags[SPAN_X1];

3873

var y1 = frags[SPAN_Y1];

3874

var x2 = frags[SPAN_X2];

3875

var y2 = frags[SPAN_Y2];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3876

var x3, y3, x3, y4, w;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3877

ctx.lineWidth = 3;

3878

ctx.strokeStyle = "rgba(0,0,255, 0.3)";

3879

focus_enabled = true;

3880

switch (fragType) {

3881

case ACTIVE_LINE_SPAN:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3882

drawLine(x1, y1, x2, y2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3883

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3884

drawLineID(frags[0], x1, y1, x2, y2);

3885

}

3886

if (pt_labels) {

3887

var curve = [x1, y1, x2, y2];

3888

ctx.fillStyle = "blue";

3889

drawPoints(curve, PATH_LINE, pt_labels == 2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3890

}

3891

break;

3892

case ACTIVE_QUAD_SPAN:

3893

x3 = frags[SPAN_X3];

3894

y3 = frags[SPAN_Y3];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3895

drawQuad(x1, y1, x2, y2, x3, y3);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3896

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3897

drawQuadID(frags[0], x1, y1, x2, y2, x3, y3);

3898

}

3899

if (pt_labels) {

3900

var curve = [x1, y1, x2, y2, x3, y3];

3901

ctx.fillStyle = "blue";

3902

drawPoints(curve, PATH_QUAD, pt_labels == 2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3903

}

3904

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3905

case ACTIVE_CONIC_SPAN:

3906

x3 = frags[SPAN_X3];

3907

y3 = frags[SPAN_Y3];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3908

w = frags[SPAN_K_W];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3909

drawConicWithQuads(x1, y1, x2, y2, x3, y3, w);

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3910

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3911

drawConicID(frags[0], x1, y1, x2, y2, x3, y3, w);

3912

}

3913

if (pt_labels) {

3914

var curve = [x1, y1, x2, y2, x3, y3, w];

3915

ctx.fillStyle = "blue";

3916

drawPoints(curve, PATH_CONIC, pt_labels == 2);

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3917

}

3918

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3919

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]

3924

drawCubic(x1, y1, x2, y2, x3, y3, x4, y4);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3925

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3926

drawCubicID(frags[0], x1, y1, x2, y2, x3, y3, x4, y4);

3927

}

3928

if (pt_labels) {

3929

var curve = [x1, y1, x2, y2, x3, y3, x4, y4];

3930

ctx.fillStyle = "blue";

3931

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);

3936

throw "stop execution";

3937

}

3938

break;

3939

case REC_TYPE_ACTIVE_OP:

3940

if (!draw_op || (step_limit > 0 && tIndex < lastOp)) {

3941

continue;

3942

}

3943

focus_enabled = true;

3944

ctx.lineWidth = 3;

3945

var activeSpan = frags[7] == "1";

3946

ctx.strokeStyle = activeSpan ? "rgba(45,160,0, 0.3)" : "rgba(255,45,0, 0.5)";

3947

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

3948

drawCurve(curve);

3949

if (draw_op > 1) {

3950

drawArc(curve, false, frags[3], frags[4]);

3951

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)"

3960

: closeCount == 1 ? "rgba(0,127,0, 0.3)"

3961

: closeCount == 2 ? "rgba(0,127,127, 0.3)"

3962

: closeCount == 3 ? "rgba(127,127,0, 0.3)"

3963

: "rgba(127,0,127, 0.3)";

3964

focus_enabled = true;

switch (fragType) {

case ADD_MOVETO:

break;

case ADD_LINETO:

if (step_limit == 0 || tIndex >= lastAdd) {

3970

drawLine(frags[0], frags[1], frags[2], frags[3]);

}

break;

case ADD_QUADTO:

if (step_limit == 0 || tIndex >= lastAdd) {

3975

drawQuad(frags[0], frags[1], frags[2], frags[3], frags[4], frags[5]);

3976

}

3977

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3978

case ADD_CONICTO:

3979

if (step_limit == 0 || tIndex >= lastAdd) {

3980

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

3981

frags[4], frags[5], frags[6]);

3982

}

3983

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3984

case ADD_CUBICTO:

3985

if (step_limit == 0 || tIndex >= lastAdd) {

3986

drawCubic(frags[0], frags[1], frags[2], frags[3],

3987

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);

3997

throw "stop execution";

3998

}

3999

break;

4000

case REC_TYPE_ANGLE:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4001

angleBetween = frags[18] == "T";

4002

afterIndex = 0;

4003

if (draw_angle == 0 || draw_angle == 3 || (step_limit > 0 && tIndex < lastAngle)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4004

continue;

4005

}

4006

focus_enabled = true;

4007

ctx.lineWidth = 3;

4008

ctx.strokeStyle = "rgba(127,45,127, 0.3)";

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4009

var leftCurve = curvePartialByID(test, frags[0], frags[4], frags[5]);

4010

var midCurve = curvePartialByID(test, frags[6], frags[10], frags[11]);

4011

var rightCurve = curvePartialByID(test, frags[12], frags[16], frags[17]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4012

drawCurve(leftCurve);

4013

drawCurve(rightCurve);

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4014

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]

4015

drawCurve(midCurve);

4016

if (draw_angle > 1) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4017

drawVisibleOrder(leftCurve, 'L');

4018

drawVisibleOrder(rightCurve, 'R');

4019

}

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

4020

if (draw_id) {

4021

drawVisibleID(leftCurve, 0.5, frags[0]);

4022

drawVisibleID(midCurve, 0.5, frags[6]);

4023

drawVisibleID(rightCurve, 0.5, frags[12]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4024

}

4025

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4026

case REC_TYPE_AFTERPART:

4027

if (draw_angle != 3 || (step_limit > 0 && tIndex < lastAngle)) {

4028

continue;

4029

}

4030

ctx.strokeStyle = afterIndex == 0 ? "rgba(255,0,0, 1.0)"

4031

: (afterIndex == 1) == angleBetween ? "rgba(0,128,0, 1.0)"

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4032

: "rgba(0,0,255, 1.0)";

4033

var curve;

4034

var id;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4035

switch (fragType) {

4036

case PATH_LINE:

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4037

curve = [ frags[0], frags[1], frags[2], frags[3] ];

4038

id = frags[4];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4039

break;

4040

case PATH_QUAD:

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4041

curve = [ frags[0], frags[1], frags[2], frags[3],

4042

frags[4], frags[5] ];

4043

id = frags[6];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4044

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4045

case PATH_CONIC:

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4046

curve = [ frags[0], frags[1], frags[2], frags[3],

4047

frags[4], frags[5], frags[6] ];

4048

id = frags[7];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4049

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4050

case PATH_CUBIC:

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4051

curve = [ frags[0], frags[1], frags[2], frags[3],

4052

frags[4], frags[5], frags[6], frags[7] ];

4053

id = frags[8];

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4054

break;

4055

default:

4056

console.log("unknown REC_TYPE_AFTERPART frag type: " + fragType);

4057

throw "stop execution";

4058

}

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4059

drawCurve(curve);

Ben Wagner

2017-10-09 14:43:00 -0400

[diff] [blame]

4060

if (draw_id) {

4061

drawVisibleID(curve, 0.5, id);

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4062

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4063

++afterIndex;

4064

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

4065

case REC_TYPE_COINCIDENCE:

4066

if (!draw_coincidence || (step_limit > 0 && tIndex < lastCoin)) {

4067

continue;

4068

}

4069

focus_enabled = true;

4070

ctx.lineWidth = 3;

4071

ctx.strokeStyle = "rgba(127,45,63, 0.3)";

4072

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

4073

drawCurve(curve);

4074

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4075

case REC_TYPE_SECT:

4076

if (!draw_intersection) {

4077

continue;

4078

}

4079

if (draw_intersection != 1 && (step_limit > 0 && tIndex < lastSect)) {

4080

continue;

4081

}

4082

// draw_intersection == 1 : show all

4083

// draw_intersection == 2 : step == 0 ? show all : show intersection line #step

4084

// draw_intersection == 3 : step == 0 ? show all : show intersection #step

4085

ctx.lineWidth = 1;

4086

ctx.strokeStyle = "rgba(0,0,255, 0.3)";

4087

ctx.fillStyle = "blue";

4088

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;

4098

break;

4099

case INTERSECT_LINE_2:

4100

f.push(5, 6, 0, 10);

4101

f.push(8, 9, 7, 15);

4102

c1s = 1; c1l = 4; c2s = 11; c2l = 4;

4103

break;

4104

case INTERSECT_LINE_NO:

4105

c1s = 0; c1l = 4; c2s = 4; c2l = 4;

4106

break;

4107

case INTERSECT_QUAD_LINE:

4108

f.push(7, 8, 0, 9);

4109

c1s = 1; c1l = 6; c2s = 10; c2l = 4;

4110

break;

4111

case INTERSECT_QUAD_LINE_2:

4112

f.push(7, 8, 0, 12);

4113

f.push(10, 11, 9, 17);

4114

c1s = 1; c1l = 6; c2s = 13; c2l = 4;

4115

break;

4116

case INTERSECT_QUAD_LINE_NO:

4117

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;

4122

break;

4123

case INTERSECT_QUAD_2:

4124

f.push(7, 8, 0, 12);

4125

f.push(10, 11, 9, 19);

4126

c1s = 1; c1l = 6; c2s = 13; c2l = 6;

4127

break;

4128

case INTERSECT_QUAD_NO:

4129

c1s = 0; c1l = 6; c2s = 6; c2l = 6;

4130

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4131

case INTERSECT_CONIC_LINE:

4132

f.push(8, 9, 0, 10);

4133

c1s = 1; c1l = 7; c2s = 11; c2l = 4;

4134

break;

4135

case INTERSECT_CONIC_LINE_2:

4136

f.push(8, 9, 0, 12);

4137

f.push(11, 12, 10, 18);

4138

c1s = 1; c1l = 7; c2s = 14; c2l = 4;

4139

break;

4140

case INTERSECT_CONIC_LINE_NO:

4141

c1s = 0; c1l = 7; c2s = 7; c2l = 4;

4142

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4143

case INTERSECT_CONIC_QUAD:

4144

f.push(8, 9, 0, 10);

4145

c1s = 1; c1l = 7; c2s = 11; c2l = 6;

4146

break;

4147

case INTERSECT_CONIC_QUAD_2:

4148

f.push(8, 9, 0, 12);

4149

f.push(11, 12, 10, 18);

4150

c1s = 1; c1l = 7; c2s = 14; c2l = 6;

4151

break;

caryclark

2016-09-26 05:36:58 -0700

[diff] [blame]

4152

case INTERSECT_CONIC_QUAD_3:

4153

f.push(8, 9, 0, 15);

4154

f.push(11, 12, 10, 21);

4155

f.push(14, 15, 13, 22);

4156

c1s = 1; c1l = 7; c2s = 17; c2l = 6;

4157

break;

4158

case INTERSECT_CONIC_QUAD_4:

4159

f.push(8, 9, 0, 18);

4160

f.push(11, 12, 10, 24);

4161

f.push(14, 15, 13, 25);

4162

f.push(17, 18, 16, 26);

4163

c1s = 1; c1l = 7; c2s = 20; c2l = 6;

4164

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4165

case INTERSECT_CONIC_QUAD_NO:

4166

c1s = 0; c1l = 7; c2s = 7; c2l = 6;

4167

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4168

case INTERSECT_CONIC:

4169

f.push(8, 9, 0, 10);

4170

c1s = 1; c1l = 7; c2s = 11; c2l = 7;

4171

break;

4172

case INTERSECT_CONIC_2:

4173

f.push(8, 9, 0, 13);

4174

f.push(11, 12, 10, 21);

4175

c1s = 1; c1l = 7; c2s = 14; c2l = 7;

4176

break;

4177

case INTERSECT_CONIC_NO:

4178

c1s = 0; c1l = 7; c2s = 7; c2l = 7;

4179

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4180

case INTERSECT_SELF_CUBIC:

4181

f.push(9, 10, 0, 11);

4182

c1s = 1; c1l = 8; c2s = 0; c2l = 0;

4183

break;

4184

case INTERSECT_SELF_CUBIC_NO:

4185

c1s = 0; c1l = 8; c2s = 0; c2l = 0;

4186

break;

4187

case INTERSECT_CUBIC_LINE:

4188

f.push(9, 10, 0, 11);

4189

c1s = 1; c1l = 8; c2s = 12; c2l = 4;

4190

break;

4191

case INTERSECT_CUBIC_LINE_2:

4192

f.push(9, 10, 0, 14);

4193

f.push(12, 13, 11, 19);

4194

c1s = 1; c1l = 8; c2s = 15; c2l = 4;

4195

break;

4196

case INTERSECT_CUBIC_LINE_3:

4197

f.push(9, 10, 0, 17);

4198

f.push(12, 13, 11, 22);

4199

f.push(15, 16, 14, 23);

4200

c1s = 1; c1l = 8; c2s = 18; c2l = 4;

4201

break;

4202

case INTERSECT_CUBIC_QUAD_NO:

4203

c1s = 0; c1l = 8; c2s = 8; c2l = 6;

4204

break;

4205

case INTERSECT_CUBIC_QUAD:

4206

f.push(9, 10, 0, 11);

4207

c1s = 1; c1l = 8; c2s = 12; c2l = 6;

4208

break;

4209

case INTERSECT_CUBIC_QUAD_2:

4210

f.push(9, 10, 0, 14);

4211

f.push(12, 13, 11, 21);

4212

c1s = 1; c1l = 8; c2s = 15; c2l = 6;

4213

break;

4214

case INTERSECT_CUBIC_QUAD_3:

4215

f.push(9, 10, 0, 17);

4216

f.push(12, 13, 11, 24);

4217

f.push(15, 16, 14, 25);

4218

c1s = 1; c1l = 8; c2s = 18; c2l = 6;

4219

break;

4220

case INTERSECT_CUBIC_QUAD_4:

4221

f.push(9, 10, 0, 20);

4222

f.push(12, 13, 11, 27);

4223

f.push(15, 16, 14, 28);

4224

f.push(18, 19, 17, 29);

4225

c1s = 1; c1l = 8; c2s = 21; c2l = 6;

4226

break;

4227

case INTERSECT_CUBIC_LINE_NO:

4228

c1s = 0; c1l = 8; c2s = 8; c2l = 4;

4229

break;

4230

case INTERSECT_CUBIC:

4231

f.push(9, 10, 0, 11);

4232

c1s = 1; c1l = 8; c2s = 12; c2l = 8;

4233

break;

4234

case INTERSECT_CUBIC_2:

4235

f.push(9, 10, 0, 14);

4236

f.push(12, 13, 11, 23);

4237

c1s = 1; c1l = 8; c2s = 15; c2l = 8;

4238

break;

4239

case INTERSECT_CUBIC_3:

4240

f.push(9, 10, 0, 17);

4241

f.push(12, 13, 11, 26);

4242

f.push(15, 16, 14, 27);

4243

c1s = 1; c1l = 8; c2s = 18; c2l = 8;

4244

break;

4245

case INTERSECT_CUBIC_4:

4246

f.push(9, 10, 0, 20);

4247

f.push(12, 13, 11, 29);

4248

f.push(15, 16, 14, 30);

4249

f.push(18, 19, 17, 31);

4250

c1s = 1; c1l = 8; c2s = 21; c2l = 8;

4251

break;

4252

case INTERSECT_CUBIC_NO:

4253

c1s = 0; c1l = 8; c2s = 8; c2l = 8;

4254

break;

4255

default:

4256

console.log("unknown REC_TYPE_SECT frag type: " + fragType);

4257

throw "stop execution";

4258

}

4259

if (draw_intersection != 1) {

4260

var id = -1;

4261

var curve;

4262

switch (c1l) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4263

case 4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4264

drawLine(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3]);

4265

if (draw_id) {

4266

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3]];

4267

id = idByCurve(test, curve, PATH_LINE);

}

break;

case 6:

drawQuad(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

4272

frags[c1s + 4], frags[c1s + 5]);

4273

if (draw_id) {

4274

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

4275

frags[c1s + 4], frags[c1s + 5]];

4276

id = idByCurve(test, curve, PATH_QUAD);

4277

}

4278

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4279

case 7:

4280

drawConicWithQuads(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

4281

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6]);

4282

if (draw_id) {

4283

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

4284

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6]];

4285

id = idByCurve(test, curve, PATH_CONIC);

4286

}

4287

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4288

case 8:

4289

drawCubic(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

4290

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6], frags[c1s + 7]);

4291

if (draw_id) {

4292

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

4293

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6], frags[c1s + 7]];

4294

id = idByCurve(test, curve, PATH_CUBIC);

}

break;

}

if (id >= 0) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4299

drawVisibleID(curve, 0.5, id);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

}

id = -1;

switch (c2l) {

case 0:

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4305

case 4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4306

drawLine(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3]);

4307

if (draw_id) {

4308

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3]];

4309

id = idByCurve(test, curve, PATH_LINE);

}

break;

case 6:

drawQuad(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

4314

frags[c2s + 4], frags[c2s + 5]);

4315

if (draw_id) {

4316

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

4317

frags[c2s + 4], frags[c2s + 5]];

4318

id = idByCurve(test, curve, PATH_QUAD);

4319

}

4320

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

4321

case 7:

4322

drawConicWithQuads(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

4323

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6]);

4324

if (draw_id) {

4325

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

4326

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6]];

4327

id = idByCurve(test, curve, PATH_CONIC);

4328

}

4329

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4330

case 8:

4331

drawCubic(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

4332

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6], frags[c2s + 7]);

4333

if (draw_id) {

4334

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

4335

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6], frags[c2s + 7]];

4336

id = idByCurve(test, curve, PATH_CUBIC);

}

break;

}

if (id >= 0) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4341

drawVisibleID(curve, 0.5, id);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4342

}

4343

}

4344

if (collect_bounds) {

4345

break;

4346

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4347

if (draw_intersection != 3 || step_limit == 0 || tIndex >= lastSect) {

4348

for (var idx = 0; idx < f.length; idx += 4) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4349

drawPoint(frags[f[idx]], frags[f[idx + 1]], true);

4350

}

4351

}

4352

if (!draw_intersectT) {

4353

break;

4354

}

4355

ctx.fillStyle = "red";

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4356

if (draw_intersection != 3 || step_limit == 0 || tIndex >= lastSect) {

4357

for (var idx = 0; idx < f.length; idx += 4) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4358

drawTAtPointUp(frags[f[idx]], frags[f[idx + 1]], frags[f[idx + 2]]);

4359

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)";

4369

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);

4378

throw "stop execution";

4379

}

4380

break;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

4381

case REC_TYPE_TOP:

4382

if (!draw_top || (step_limit > 0 && tIndex < lastTop)) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = "rgba(127,127,0, 0.5)";

4387

focus_enabled = true;

4388

{

4389

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

4390

drawCurve(curve);

4391

var type = PATH_LINE + (curve.length / 2 - 2);

4392

var mid = pointAtT(curve, type, 0.5);

4393

var d = dxy_at_t(curve, type, 0.5);

4394

drawArrow(mid.x, mid.y, d.x, d.y, 0.3);

4395

}

4396

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4397

case REC_TYPE_MARK:

4398

if (!draw_mark || (step_limit > 0 && tIndex < lastMark)) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = fragType >= MARK_DONE_LINE ?

4403

"rgba(127,0,127, 0.5)" : "rgba(127,127,0, 0.5)";

4404

focus_enabled = true;

switch (fragType) {

case MARK_LINE:

case MARK_DONE_LINE:

case MARK_UNSORTABLE_LINE:

4409

case MARK_SIMPLE_LINE:

4410

case MARK_SIMPLE_DONE_LINE:

4411

case MARK_DONE_UNARY_LINE:

4412

drawLinePartial(frags[1], frags[2], frags[3], frags[4],

4413

frags[5], frags[9]);

4414

if (draw_id) {

4415

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:

4422

case MARK_SIMPLE_QUAD:

4423

case MARK_SIMPLE_DONE_QUAD:

4424

case MARK_DONE_UNARY_QUAD:

4425

drawQuadPartial(frags[1], frags[2], frags[3], frags[4],

4426

frags[5], frags[6], frags[7], frags[11]);

4427

if (draw_id) {

4428

drawQuadPartialID(frags[0], frags[1], frags[2], frags[3], frags[4],

4429

frags[5], frags[6], frags[7], frags[11]);

}

break;

case MARK_CUBIC:

case MARK_DONE_CUBIC:

4434

case MARK_UNSORTABLE_CUBIC:

4435

case MARK_SIMPLE_CUBIC:

4436

case MARK_SIMPLE_DONE_CUBIC:

4437

case MARK_DONE_UNARY_CUBIC:

4438

drawCubicPartial(frags[1], frags[2], frags[3], frags[4],

4439

frags[5], frags[6], frags[7], frags[8], frags[9], frags[13]);

4440

if (draw_id) {

4441

drawCubicPartialID(frags[0], frags[1], frags[2], frags[3], frags[4],

4442

frags[5], frags[6], frags[7], frags[8], frags[9], frags[13]);

4443

}

4444

break;

4445

case MARK_ANGLE_LAST:

4446

// FIXME: ignored for now

4447

break;

4448

default:

4449

console.log("unknown REC_TYPE_MARK frag type: " + fragType);

4450

throw "stop execution";

}

break;

default:

continue;

}

}

switch (recType) {

case REC_TYPE_SORT:

if (!draw_sort || (step_limit > 0 && tIndex < lastSort)) {

4460

break;

4461

}

4462

var angles = []; // use tangent lines to describe arcs

var windFrom = [];

var windTo = [];

var opp = [];

var minXY = Number.MAX_VALUE;

4467

var partial;

4468

focus_enabled = true;

4469

var someUnsortable = false;

4470

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

4471

var fragType = records[recordIndex];

4472

var frags = records[recordIndex + 1];

4473

var unsortable = (fragType == SORT_UNARY && frags[14]) ||

4474

(fragType == SORT_BINARY && frags[16]);

4475

someUnsortable |= unsortable;

switch (fragType) {

case SORT_UNARY:

case SORT_BINARY:

partial = curvePartialByID(test, frags[0], frags[6], frags[8]);

4480

break;

4481

default:

4482

console.log("unknown REC_TYPE_SORT frag type: " + fragType);

4483

throw "stop execution";

4484

}

4485

var dx = boundsWidth(partial);

4486

var dy = boundsHeight(partial);

4487

minXY = Math.min(minXY, dx * dx + dy * dy);

4488

if (collect_bounds) {

4489

continue;

4490

}

4491

angles.push(tangent(partial));

4492

var from = frags[12];

var to = frags[12];

var sgn = frags[10];

if (sgn < 0) {

from -= frags[11];

} else if (sgn > 0) {

4498

to -= frags[11];

4499

}

4500

windFrom.push(from + (unsortable ? "!" : ""));

4501

windTo.push(to + (unsortable ? "!" : ""));

4502

opp.push(fragType == SORT_BINARY);

4503

if (draw_sort == 1) {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4504

drawVisibleOrder(partial, frags[12]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4505

} else {

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4506

drawVisibleOrder(partial, (recordIndex / 2) + 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4507

}

4508

}

4509

var radius = Math.sqrt(minXY) / 2 * scale;

4510

radius = Math.min(50, radius);

4511

var scaledRadius = radius / scale;

4512

var centerX = partial[0];

4513

var centerY = partial[1];

4514

if (collect_bounds) {

4515

if (focus_enabled) {

4516

focusXmin = Math.min(focusXmin, centerX - scaledRadius);

4517

focusYmin = Math.min(focusYmin, centerY - scaledRadius);

4518

focusXmax = Math.max(focusXmax, centerX + scaledRadius);

4519

focusYmax = Math.max(focusYmax, centerY + scaledRadius);

}

break;

}

break;

default:

break;

}

}

if (collect_bounds) {

4529

return;

4530

}

4531

if (draw_log && logStart >= 0) {

4532

ctx.font = "normal 10px Arial";

4533

ctx.textAlign = "left";

4534

ctx.beginPath();

4535

var top = screenHeight - 20 - (logRange + 2) * 10;

4536

ctx.rect(50, top, screenWidth - 100, (logRange + 2) * 10);

4537

ctx.fillStyle = "white";

4538

ctx.fill();

4539

ctx.fillStyle = "rgba(0,0,0, 0.5)";

4540

if (logStart > 0) {

4541

ctx.fillText(lines[logStart - 1], 50, top + 8);

4542

}

4543

ctx.fillStyle = "black";

4544

for (var idx = 0; idx < logRange; ++idx) {

4545

ctx.fillText(lines[logStart + idx], 50, top + 18 + 10 * idx);

4546

}

4547

ctx.fillStyle = "rgba(0,0,0, 0.5)";

4548

if (logStart + logRange < lines.length) {

4549

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]

4554

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4555

// drawBox(pos++, "yellow", "black", opLetter, true, '');

4556

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_intersection > 1 ? sectCount : sectMax2, draw_intersection, intersectionKey);

4557

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_add ? addCount : addMax, draw_add, addKey);

4558

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_active ? activeCount : activeMax, draw_active, activeKey);

4559

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]

4560

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]

4561

drawBox(pos++, "rgba(127,127,0, 0.3)", "black", draw_op ? opCount : opMax, draw_op, opKey);

4562

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]

4563

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]

4564

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]

4565

drawBox(pos++, "black", "white",

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

4566

(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]

4567

drawBox(pos++, "rgba(0,63,0, 0.7)", "white",

4568

(new Array('Q', 'Q', 'C', 'QC', 'Qc', 'Cq'))[draw_computed],

4569

draw_computed != 0, computedKey);

4570

drawBox(pos++, "green", "black", step_limit, drawSomething, '');

4571

drawBox(pos++, "green", "black", stepMax, drawSomething, '');

4572

drawBox(pos++, "rgba(255,0,0, 0.6)", "black", lastIndex, drawSomething & draw_log, '');

4573

drawBox(pos++, "rgba(255,0,0, 0.6)", "black", test.length - 1, drawSomething & draw_log, '');

if (curve_t) {

drawCurveTControl();

}

ctx.font = "normal 20px Arial";

4578

ctx.fillStyle = "rgba(0,0,0, 0.3)";

4579

ctx.textAlign = "right";

4580

ctx.fillText(scale.toFixed(decimal_places) + 'x' , screenWidth - 10, screenHeight - 5);

4581

}

4582

if (draw_hints) {

4583

ctx.font = "normal 10px Arial";

4584

ctx.fillStyle = "rgba(0,0,0, 0.5)";

4585

ctx.textAlign = "right";

4586

var y = 4;

4587

ctx.fillText("control lines : " + controlLinesKey, ctx.screenWidthwidth - 10, pos * 50 + y++ * 10);

4588

ctx.fillText("curve t : " + curveTKey, screenWidth - 10, pos * 50 + y++ * 10);

4589

ctx.fillText("deriviatives : " + deriviativesKey, screenWidth - 10, pos * 50 + y++ * 10);

4590

ctx.fillText("intersect t : " + intersectTKey, screenWidth - 10, pos * 50 + y++ * 10);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4591

ctx.fillText("log : " + logKey, screenWidth - 10, pos * 50 + y++ * 10);

4592

ctx.fillText("log curve : " + logCurvesKey, screenWidth - 10, pos * 50 + y++ * 10);

4593

ctx.fillText("mid point : " + midpointKey, screenWidth - 10, pos * 50 + y++ * 10);

4594

ctx.fillText("points : " + ptsKey, screenWidth - 10, pos * 50 + y++ * 10);

4595

ctx.fillText("sequence : " + sequenceKey, screenWidth - 10, pos * 50 + y++ * 10);

4596

ctx.fillText("xy : " + xyKey, screenWidth - 10, pos * 50 + y++ * 10);

}

}

function drawBox(y, backC, foreC, str, enable, label) {

4601

ctx.beginPath();

4602

ctx.fillStyle = backC;

4603

ctx.rect(screenWidth - 40, y * 50 + 10, 40, 30);

4604

ctx.fill();

4605

ctx.font = "normal 16px Arial";

4606

ctx.fillStyle = foreC;

4607

ctx.textAlign = "center";

4608

ctx.fillText(str, screenWidth - 20, y * 50 + 32);

4609

if (!enable) {

4610

ctx.fillStyle = "rgba(255,255,255, 0.5)";

ctx.fill();

}

if (label != '') {

ctx.font = "normal 9px Arial";

4615

ctx.fillStyle = "black";

4616

ctx.fillText(label, screenWidth - 47, y * 50 + 40);

}

}

function drawCurveTControl() {

4621

ctx.lineWidth = 2;

4622

ctx.strokeStyle = "rgba(0,0,0, 0.3)";

4623

ctx.beginPath();

4624

ctx.rect(screenWidth - 80, 40, 28, screenHeight - 80);

4625

ctx.stroke();

4626

var ty = 40 + curveT * (screenHeight - 80);

4627

ctx.beginPath();

4628

ctx.moveTo(screenWidth - 80, ty);

4629

ctx.lineTo(screenWidth - 85, ty - 5);

4630

ctx.lineTo(screenWidth - 85, ty + 5);

4631

ctx.lineTo(screenWidth - 80, ty);

4632

ctx.fillStyle = "rgba(0,0,0, 0.6)";

4633

ctx.fill();

4634

var num = curveT.toFixed(decimal_places);

4635

ctx.font = "normal 10px Arial";

4636

ctx.textAlign = "left";

4637

ctx.fillText(num, screenWidth - 78, ty);

4638

}

4639

4640

function ptInTControl() {

4641

var e = window.event;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4642

var tgt = e.target || e.srcElement;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4643

var left = tgt.offsetLeft;

4644

var top = tgt.offsetTop;

4645

var x = (e.clientX - left);

4646

var y = (e.clientY - top);

4647

if (x < screenWidth - 80 || x > screenWidth - 50) {

4648

return false;

4649

}

4650

if (y < 40 || y > screenHeight - 80) {

4651

return false;

4652

}

4653

curveT = (y - 40) / (screenHeight - 120);

4654

if (curveT < 0 || curveT > 1) {

4655

throw "stop execution";

}

return true;

}

function drawTop() {

if (tests[testIndex] == null) {

4662

var str = testDivs[testIndex].textContent;

4663

parse_all(str);

4664

var title = testDivs[testIndex].id.toString();

4665

testTitles[testIndex] = title;

4666

}

4667

init(tests[testIndex]);

redraw();

}

function redraw() {

if (focus_on_selection) {

4673

collect_bounds = true;

4674

draw(tests[testIndex], testLines[testIndex], testTitles[testIndex]);

4675

collect_bounds = false;

4676

if (focusXmin < focusXmax && focusYmin < focusYmax) {

4677

setScale(focusXmin, focusXmax, focusYmin, focusYmax);

}

}

ctx.beginPath();

ctx.fillStyle = "white";

4682

ctx.rect(0, 0, screenWidth, screenHeight);

4683

ctx.fill();

4684

draw(tests[testIndex], testLines[testIndex], testTitles[testIndex]);

4685

}

4686

4687

function dumpCurvePartial(test, id, t0, t1) {

4688

var curve = curveByID(test, id);

4689

var name = ["line", "quad", "cubic"][curve.length / 2 - 2];

4690

console.log("id=" + id + " " + name + "=" + curveToString(curve)

4691

+ " t0=" + t0 + " t1=" + t1

4692

+ " partial=" + curveToString(curvePartialByID(test, id, t0, t1)));

4693

}

4694

4695

function dumpAngleTest(test, id, t0, t1) {

4696

var curve = curveByID(test, id);

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4697

console.log(" { {" + curveToString(curve) + "}, "

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4698

+ curve.length / 2 + ", " + t0 + ", " + t1 + ", {} }, //");

4699

}

4700

4701

function dumpLogToConsole() {

if (logStart < 0) {

return;

}

var test = tests[testIndex];

4706

var recType = REC_TYPE_UNKNOWN;

4707

var records;

4708

for (var index = 0; index < test.length; index += 3) {

4709

var lastLineNo = test[index + 1];

4710

if (lastLineNo >= logStart && lastLineNo < logStart + logRange) {

4711

recType = test[index];

4712

records = test[index + 2];

break;

}

}

if (recType == REC_TYPE_UNKNOWN) {

4717

return;

4718

}

4719

var lines = testLines[testIndex];

4720

for (var idx = 0; idx < logRange; ++idx) {

4721

var line = lines[logStart + idx];

4722

console.log(line);

4723

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

4724

var fragType = records[recordIndex];

4725

var frags = records[recordIndex + 1];

4726

if (recType == REC_TYPE_ANGLE && fragType == ANGLE_AFTER) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4727

dumpCurvePartial(test, frags[0], frags[4], frags[5]);

4728

dumpCurvePartial(test, frags[6], frags[10], frags[11]);

4729

dumpCurvePartial(test, frags[12], frags[16], frags[17]);

4730

console.log("\nstatic IntersectData intersectDataSet[] = { //");

4731

dumpAngleTest(test, frags[0], frags[4], frags[5]);

4732

dumpAngleTest(test, frags[6], frags[10], frags[11]);

4733

dumpAngleTest(test, frags[12], frags[16], frags[17]);

4734

console.log("}; //");

}

}

}

}

var activeKey = 'a';

var pathKey = 'b';

var pathBackKey = 'B';

4743

var centerKey = 'c';

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

4744

var coincidenceKey = 'C';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4745

var addKey = 'd';

4746

var deriviativesKey = 'f';

4747

var angleKey = 'g';

4748

var angleBackKey = 'G';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4749

var intersectionKey = 'i';

4750

var intersectionBackKey = 'I';

4751

var sequenceKey = 'j';

4752

var midpointKey = 'k';

4753

var logKey = 'l';

4754

var logToConsoleKey = 'L';

var markKey = 'm';

var sortKey = 'o';

var opKey = 'p';

var opBackKey = 'P';

var computedKey = 'q';

4760

var computedBackKey = 'Q';

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4761

var directionKey = 'r';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4762

var stepKey = 's';

4763

var stepBackKey = 'S';

4764

var intersectTKey = 't';

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

4765

var topKey = 'T';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4766

var curveTKey = 'u';

4767

var controlLinesBackKey = 'V';

4768

var controlLinesKey = 'v';

4769

var ptsKey = 'x';

4770

var xyKey = 'y';

4771

var logCurvesKey = 'z';

4772

var focusKey = '`';

4773

var idKey = '.';

4774

var retinaKey = '\\';

4775

4776

function doKeyPress(evt) {

4777

var char = String.fromCharCode(evt.charCode);

4778

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]

4795

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4796

break;

4797

case addKey:

4798

draw_add ^= true;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4799

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4800

break;

4801

case angleKey:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4802

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]

4811

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4812

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

4813

case coincidenceKey:

4814

draw_coincidence ^= true;

4815

redraw();

4816

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4817

case controlLinesBackKey:

4818

control_lines = (control_lines + 3) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4819

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4820

break;

4821

case controlLinesKey:

4822

control_lines = (control_lines + 1) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4823

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4824

break;

4825

case computedBackKey:

4826

draw_computed = (draw_computed + 5) % 6;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4827

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4828

break;

4829

case computedKey:

4830

draw_computed = (draw_computed + 1) % 6;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4831

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:

4841

draw_deriviatives = (draw_deriviatives + 1) % 3;

4842

redraw();

4843

break;

Cary Clark

2016-12-14 11:56:16 -0500

[diff] [blame]

4844

case directionKey:

4845

draw_direction ^= true;

4846

redraw();

4847

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4848

case focusKey:

4849

focus_on_selection ^= true;

4850

setScale(xmin, xmax, ymin, ymax);

4851

redraw();

4852

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

case idKey:

draw_id ^= true;

redraw();

break;

case intersectionBackKey:

4858

draw_intersection = (draw_intersection + 3) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4859

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4860

break;

4861

case intersectionKey:

4862

draw_intersection = (draw_intersection + 1) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4863

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4864

break;

4865

case intersectTKey:

4866

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;

4895

redraw();

4896

break;

4897

case pathKey:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

4898

draw_path = (draw_path + 1) % (4 + (hasAlignedPath ? 3 : 0));

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4899

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4900

break;

4901

case pathBackKey:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

4902

draw_path = (draw_path + 3 + (hasAlignedPath ? 3 : 0)) % (4 + (hasAlignedPath ? 3 : 0));

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

4903

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4904

break;

4905

case ptsKey:

4906

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) {

4924

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]

4939

case xyKey:

4940

debug_xy = (debug_xy + 1) % 3;

redraw();

break;

case '-':

focusWasOn = focus_on_selection;

4945

if (focusWasOn) {

4946

focus_on_selection = false;

scale /= 1.2;

} else {

scale /= 2;

calcLeftTop();

}

redraw();

focus_on_selection = focusWasOn;

break;

case '=':

case '+':

focusWasOn = focus_on_selection;

4958

if (focusWasOn) {

4959

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) {

4983

var char = evt.keyCode;

4984

var preventDefault = false;

4985

switch (char) {

4986

case 37: // left arrow

if (evt.shiftKey) {

testIndex -= 9;

}

if (--testIndex < 0)

testIndex = tests.length - 1;

4992

drawTop();

4993

preventDefault = true;

4994

break;

4995

case 39: // right arrow

if (evt.shiftKey) {

testIndex += 9;

}

if (++testIndex >= tests.length)

5000

testIndex = 0;

5001

drawTop();

5002

preventDefault = true;

5003

break;

5004

}

5005

if (preventDefault) {

5006

evt.preventDefault();

return false;

}

return true;

}

(function() {

var hidden = "hidden";

5014

5015

// Standards:

5016

if (hidden in document)

5017

document.addEventListener("visibilitychange", onchange);

5018

else if ((hidden = "mozHidden") in document)

5019

document.addEventListener("mozvisibilitychange", onchange);

5020

else if ((hidden = "webkitHidden") in document)

5021

document.addEventListener("webkitvisibilitychange", onchange);

5022

else if ((hidden = "msHidden") in document)

5023

document.addEventListener("msvisibilitychange", onchange);

5024

// IE 9 and lower:

5025

else if ('onfocusin' in document)

5026

document.onfocusin = document.onfocusout = onchange;

5027

// All others:

5028

else

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

5029

window.onpageshow = window.onpagehide

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

5030

= window.onfocus = window.onblur = onchange;

5031

5032

function onchange (evt) {

5033

var v = 'visible', h = 'hidden',

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

5034

evtMap = {

5035

focus:v, focusin:v, pageshow:v, blur:h, focusout:h, pagehide:h

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

5036

};

5037

5038

evt = evt || window.event;

5039

if (evt.type in evtMap)

5040

document.body.className = evtMap[evt.type];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

5041

else

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

5042

document.body.className = this[hidden] ? "hidden" : "visible";

}

})();

function calcXY() {

var e = window.event;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

5048

var tgt = e.target || e.srcElement;

caryclark