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

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

[diff] [blame]

87

</div>

caryclark

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

[diff] [blame]

88

caryclark

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

[diff] [blame]

</div>

caryclark

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

[diff] [blame]

93

var testDivs = [

caryclark

81a478c

2016-09-09 09:37:57 -0700

[diff] [blame]

94

tiger8b_h_1,

caryclark

30b9fdd

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

[diff] [blame]

95

];

caryclark

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

[diff] [blame]

96

97

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;

106

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]

111

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;

116

var control_lines = 0;

117

var curve_t = false;

118

var debug_xy = 1;

119

var focus_enabled = false;

120

var focus_on_selection = false;

121

var step_limit = 0;

122

var draw_active = false;

123

var draw_add = false;

124

var draw_angle = 0;

caryclark

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

[diff] [blame]

125

var draw_coincidence = false;

caryclark

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

[diff] [blame]

126

var draw_deriviatives = 0;

127

var draw_hints = false;

caryclark

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

[diff] [blame]

128

var draw_id = false;

129

var draw_intersection = 0;

130

var draw_intersectT = false;

131

var draw_legend = true;

132

var draw_log = false;

133

var draw_mark = false;

134

var draw_midpoint = false;

135

var draw_op = 0;

136

var draw_sequence = false;

137

var draw_sort = 0;

caryclark

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

[diff] [blame]

138

var draw_top = false;

caryclark

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

[diff] [blame]

139

var draw_path = 3;

140

var draw_computed = 0;

141

var retina_scale = !!window.devicePixelRatio;

var activeCount = 0;

var addCount = 0;

var angleCount = 0;

caryclark

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

[diff] [blame]

146

var coinCount = 0;

caryclark

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

[diff] [blame]

147

var opCount = 0;

148

var sectCount = 0;

149

var sortCount = 0;

caryclark

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

[diff] [blame]

150

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]

155

var coinMax = 0;

caryclark

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

[diff] [blame]

156

var sectMax = 0;

157

var sectMax2 = 0;

158

var sortMax = 0;

caryclark

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

[diff] [blame]

159

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]

165

var hasAlignedPath = false;

caryclark

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

[diff] [blame]

166

var hasComputedPath = false;

caryclark

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

[diff] [blame]

167

var angleBetween = false;

168

var afterIndex = 0;

caryclark

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

[diff] [blame]

169

170

var firstActiveSpan = -1;

var logStart = -1;

var logRange = 0;

var SPAN_ID = 0;

var SPAN_X1 = SPAN_ID + 1;

176

var SPAN_Y1 = SPAN_X1 + 1;

177

var SPAN_X2 = SPAN_Y1 + 1;

178

var SPAN_Y2 = SPAN_X2 + 1;

caryclark

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

[diff] [blame]

179

caryclark

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

[diff] [blame]

180

var SPAN_L_TX = SPAN_Y2 + 1;

caryclark

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

[diff] [blame]

181

var SPAN_L_TY = SPAN_L_TX + 1;

caryclark

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

[diff] [blame]

182

var SPAN_L_OTHER = SPAN_L_TY + 1;

caryclark

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

[diff] [blame]

183

var SPAN_L_OTHERT = SPAN_L_OTHER + 1;

184

var SPAN_L_OTHERI = SPAN_L_OTHERT + 1;

185

var SPAN_L_SUM = SPAN_L_OTHERI + 1;

186

var SPAN_L_VAL = SPAN_L_SUM + 1;

187

var SPAN_L_OPP = SPAN_L_VAL + 1;

188

189

var SPAN_X3 = SPAN_Y2 + 1;

190

var SPAN_Y3 = SPAN_X3 + 1;

caryclark

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

[diff] [blame]

191

caryclark

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

[diff] [blame]

192

var SPAN_Q_TX = SPAN_Y3 + 1;

caryclark

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

[diff] [blame]

193

var SPAN_Q_TY = SPAN_Q_TX + 1;

caryclark

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

[diff] [blame]

194

var SPAN_Q_OTHER = SPAN_Q_TY + 1;

caryclark

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

[diff] [blame]

195

var SPAN_Q_OTHERT = SPAN_Q_OTHER + 1;

196

var SPAN_Q_OTHERI = SPAN_Q_OTHERT + 1;

197

var SPAN_Q_SUM = SPAN_Q_OTHERI + 1;

198

var SPAN_Q_VAL = SPAN_Q_SUM + 1;

199

var SPAN_Q_OPP = SPAN_Q_VAL + 1;

200

caryclark

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

[diff] [blame]

201

var SPAN_K_W = SPAN_Y3 + 1;

caryclark

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

[diff] [blame]

202

var SPAN_K_TX = SPAN_K_W + 1;

caryclark

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

[diff] [blame]

203

var SPAN_K_TY = SPAN_K_TX + 1;

caryclark

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

[diff] [blame]

204

var SPAN_K_OTHER = SPAN_K_TY + 1;

caryclark

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

[diff] [blame]

205

var SPAN_K_OTHERT = SPAN_K_OTHER + 1;

206

var SPAN_K_OTHERI = SPAN_K_OTHERT + 1;

207

var SPAN_K_SUM = SPAN_K_OTHERI + 1;

208

var SPAN_K_VAL = SPAN_K_SUM + 1;

209

var SPAN_K_OPP = SPAN_K_VAL + 1;

210

caryclark

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

[diff] [blame]

211

var SPAN_X4 = SPAN_Y3 + 1;

212

var SPAN_Y4 = SPAN_X4 + 1;

caryclark

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

[diff] [blame]

213

caryclark

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

[diff] [blame]

214

var SPAN_C_TX = SPAN_Y4 + 1;

caryclark

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

[diff] [blame]

215

var SPAN_C_TY = SPAN_C_TX + 1;

caryclark

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

[diff] [blame]

216

var SPAN_C_OTHER = SPAN_C_TY + 1;

caryclark

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

[diff] [blame]

217

var SPAN_C_OTHERT = SPAN_C_OTHER + 1;

218

var SPAN_C_OTHERI = SPAN_C_OTHERT + 1;

219

var SPAN_C_SUM = SPAN_C_OTHERI + 1;

220

var SPAN_C_VAL = SPAN_C_SUM + 1;

221

var SPAN_C_OPP = SPAN_C_VAL + 1;

222

223

var ACTIVE_LINE_SPAN = 1;

224

var ACTIVE_QUAD_SPAN = ACTIVE_LINE_SPAN + 1;

caryclark

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

[diff] [blame]

225

var ACTIVE_CONIC_SPAN = ACTIVE_QUAD_SPAN + 1;

226

var ACTIVE_CUBIC_SPAN = ACTIVE_CONIC_SPAN + 1;

caryclark

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

[diff] [blame]

227

228

var ADD_MOVETO = ACTIVE_CUBIC_SPAN + 1;

229

var ADD_LINETO = ADD_MOVETO + 1;

230

var ADD_QUADTO = ADD_LINETO + 1;

caryclark

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

[diff] [blame]

231

var ADD_CONICTO = ADD_QUADTO + 1;

232

var ADD_CUBICTO = ADD_CONICTO + 1;

caryclark

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

[diff] [blame]

233

var ADD_CLOSE = ADD_CUBICTO + 1;

234

var ADD_FILL = ADD_CLOSE + 1;

235

236

var PATH_LINE = ADD_FILL + 1;

237

var PATH_QUAD = PATH_LINE + 1;

caryclark

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

[diff] [blame]

238

var PATH_CONIC = PATH_QUAD + 1;

239

var PATH_CUBIC = PATH_CONIC + 1;

caryclark

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

[diff] [blame]

240

241

var INTERSECT_LINE = PATH_CUBIC + 1;

242

var INTERSECT_LINE_2 = INTERSECT_LINE + 1;

243

var INTERSECT_LINE_NO = INTERSECT_LINE_2 + 1;

244

var INTERSECT_QUAD_LINE = INTERSECT_LINE_NO + 1;

245

var INTERSECT_QUAD_LINE_2 = INTERSECT_QUAD_LINE + 1;

246

var INTERSECT_QUAD_LINE_NO = INTERSECT_QUAD_LINE_2 + 1;

247

var INTERSECT_QUAD = INTERSECT_QUAD_LINE_NO + 1;

248

var INTERSECT_QUAD_2 = INTERSECT_QUAD + 1;

249

var INTERSECT_QUAD_NO = INTERSECT_QUAD_2 + 1;

caryclark

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

[diff] [blame]

250

var INTERSECT_CONIC_LINE = INTERSECT_QUAD_NO + 1;

251

var INTERSECT_CONIC_LINE_2 = INTERSECT_CONIC_LINE + 1;

252

var INTERSECT_CONIC_LINE_NO = INTERSECT_CONIC_LINE_2 + 1;

caryclark

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

[diff] [blame]

253

var INTERSECT_CONIC_QUAD = INTERSECT_CONIC_LINE_NO + 1;

254

var INTERSECT_CONIC_QUAD_2 = INTERSECT_CONIC_QUAD + 1;

255

var INTERSECT_CONIC_QUAD_NO = INTERSECT_CONIC_QUAD_2 + 1;

256

var INTERSECT_CONIC = INTERSECT_CONIC_QUAD_NO + 1;

caryclark

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

[diff] [blame]

257

var INTERSECT_CONIC_2 = INTERSECT_CONIC + 1;

258

var INTERSECT_CONIC_NO = INTERSECT_CONIC_2 + 1;

259

var INTERSECT_SELF_CUBIC = INTERSECT_CONIC_NO + 1;

caryclark

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

[diff] [blame]

260

var INTERSECT_SELF_CUBIC_NO = INTERSECT_SELF_CUBIC + 1;

261

var INTERSECT_CUBIC_LINE = INTERSECT_SELF_CUBIC_NO + 1;

262

var INTERSECT_CUBIC_LINE_2 = INTERSECT_CUBIC_LINE + 1;

263

var INTERSECT_CUBIC_LINE_3 = INTERSECT_CUBIC_LINE_2 + 1;

264

var INTERSECT_CUBIC_LINE_NO = INTERSECT_CUBIC_LINE_3 + 1;

265

var INTERSECT_CUBIC_QUAD = INTERSECT_CUBIC_LINE_NO + 1;

266

var INTERSECT_CUBIC_QUAD_2 = INTERSECT_CUBIC_QUAD + 1;

267

var INTERSECT_CUBIC_QUAD_3 = INTERSECT_CUBIC_QUAD_2 + 1;

268

var INTERSECT_CUBIC_QUAD_4 = INTERSECT_CUBIC_QUAD_3 + 1;

269

var INTERSECT_CUBIC_QUAD_NO = INTERSECT_CUBIC_QUAD_4 + 1;

270

var INTERSECT_CUBIC = INTERSECT_CUBIC_QUAD_NO + 1;

271

var INTERSECT_CUBIC_2 = INTERSECT_CUBIC + 1;

272

var INTERSECT_CUBIC_3 = INTERSECT_CUBIC_2 + 1;

273

var INTERSECT_CUBIC_4 = INTERSECT_CUBIC_3 + 1;

274

// FIXME: add cubic 5- 9

275

var INTERSECT_CUBIC_NO = INTERSECT_CUBIC_4 + 1;

276

277

var SORT_UNARY = INTERSECT_CUBIC_NO + 1;

278

var SORT_BINARY = SORT_UNARY + 1;

279

280

var OP_DIFFERENCE = SORT_BINARY + 1;

281

var OP_INTERSECT = OP_DIFFERENCE + 1;

282

var OP_UNION = OP_INTERSECT + 1;

283

var OP_XOR = OP_UNION + 1;

284

285

var MARK_LINE = OP_XOR + 1;

286

var MARK_QUAD = MARK_LINE + 1;

caryclark

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

[diff] [blame]

287

var MARK_CONIC = MARK_QUAD + 1;

288

var MARK_CUBIC = MARK_CONIC + 1;

caryclark

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

[diff] [blame]

289

var MARK_DONE_LINE = MARK_CUBIC + 1;

290

var MARK_DONE_QUAD = MARK_DONE_LINE + 1;

caryclark

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

[diff] [blame]

291

var MARK_DONE_CONIC = MARK_DONE_QUAD + 1;

292

var MARK_DONE_CUBIC = MARK_DONE_CONIC + 1;

caryclark

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

[diff] [blame]

293

var MARK_UNSORTABLE_LINE = MARK_DONE_CUBIC + 1;

294

var MARK_UNSORTABLE_QUAD = MARK_UNSORTABLE_LINE + 1;

caryclark

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

[diff] [blame]

295

var MARK_UNSORTABLE_CONIC = MARK_UNSORTABLE_QUAD + 1;

296

var MARK_UNSORTABLE_CUBIC = MARK_UNSORTABLE_CONIC + 1;

caryclark

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

[diff] [blame]

297

var MARK_SIMPLE_LINE = MARK_UNSORTABLE_CUBIC + 1;

298

var MARK_SIMPLE_QUAD = MARK_SIMPLE_LINE + 1;

caryclark

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

[diff] [blame]

299

var MARK_SIMPLE_CONIC = MARK_SIMPLE_QUAD + 1;

300

var MARK_SIMPLE_CUBIC = MARK_SIMPLE_CONIC + 1;

caryclark

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

[diff] [blame]

301

var MARK_SIMPLE_DONE_LINE = MARK_SIMPLE_CUBIC + 1;

302

var MARK_SIMPLE_DONE_QUAD = MARK_SIMPLE_DONE_LINE + 1;

caryclark

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

[diff] [blame]

303

var MARK_SIMPLE_DONE_CONIC = MARK_SIMPLE_DONE_QUAD + 1;

304

var MARK_SIMPLE_DONE_CUBIC = MARK_SIMPLE_DONE_CONIC + 1;

caryclark

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

[diff] [blame]

305

var MARK_DONE_UNARY_LINE = MARK_SIMPLE_DONE_CUBIC + 1;

306

var MARK_DONE_UNARY_QUAD = MARK_DONE_UNARY_LINE + 1;

caryclark

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

[diff] [blame]

307

var MARK_DONE_UNARY_CONIC = MARK_DONE_UNARY_QUAD + 1;

308

var MARK_DONE_UNARY_CUBIC = MARK_DONE_UNARY_CONIC + 1;

caryclark

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

[diff] [blame]

309

var MARK_ANGLE_LAST = MARK_DONE_UNARY_CUBIC + 1;

310

311

var COMPUTED_SET_1 = MARK_ANGLE_LAST + 1;

312

var COMPUTED_SET_2 = COMPUTED_SET_1 + 1;

313

caryclark

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

[diff] [blame]

314

var ANGLE_AFTER = COMPUTED_SET_2 + 1;

caryclark

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

[diff] [blame]

315

var ANGLE_AFTERPART = ANGLE_AFTER + 1;

caryclark

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

[diff] [blame]

316

caryclark

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

[diff] [blame]

317

var ACTIVE_OP = ANGLE_AFTERPART + 1;

caryclark

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

[diff] [blame]

318

caryclark

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

[diff] [blame]

319

var COIN_MAIN_SPAN = ACTIVE_OP + 1;

320

var COIN_OPP_SPAN = COIN_MAIN_SPAN + 1;

321

322

var FRAG_TYPE_LAST = COIN_OPP_SPAN;

caryclark

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

[diff] [blame]

323

324

var REC_TYPE_UNKNOWN = -1;

325

var REC_TYPE_PATH = 0;

caryclark

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

[diff] [blame]

326

var REC_TYPE_PATH2 = 1;

327

var REC_TYPE_SECT = 2;

328

var REC_TYPE_ACTIVE = 3;

329

var REC_TYPE_ADD = 4;

330

var REC_TYPE_SORT = 5;

331

var REC_TYPE_OP = 6;

332

var REC_TYPE_MARK = 7;

333

var REC_TYPE_COMPUTED = 8;

334

var REC_TYPE_COIN = 9;

335

var REC_TYPE_ANGLE = 10;

336

var REC_TYPE_ACTIVE_OP = 11;

337

var REC_TYPE_AFTERPART = 12;

caryclark

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

[diff] [blame]

338

var REC_TYPE_TOP = 13;

caryclark

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

[diff] [blame]

339

var REC_TYPE_COINCIDENCE = 14;

caryclark

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

[diff] [blame]

340

var REC_TYPE_ALIGNED = 15;

341

var REC_TYPE_LAST = REC_TYPE_ALIGNED;

caryclark

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

[diff] [blame]

342

343

function strs_to_nums(strs) {

344

var result = [];

345

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

346

var str = strs[idx];

347

var num = parseFloat(str);

if (isNaN(num)) {

result.push(str);

} else {

result.push(num);

}

}

return result;

}

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

358

if (regex.test(str)) {

359

var strs = regex.exec(str);

360

var result = strs_to_nums(strs);

array.push(id);

array.push(result);

return true;

}

return false;

}

function construct_regexp2(pattern) {

369

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

370

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

371

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

caryclark

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

[diff] [blame]

372

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

caryclark

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

[diff] [blame]

373

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

374

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

375

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

caryclark

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

[diff] [blame]

376

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

caryclark

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

[diff] [blame]

377

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

378

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

379

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

caryclark

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

[diff] [blame]

380

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

caryclark

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

[diff] [blame]

381

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

caryclark

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

[diff] [blame]

382

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

caryclark

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

[diff] [blame]

383

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

384

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

385

return new RegExp(escape, 'i');

386

}

387

388

function construct_regexp2c(pattern) {

389

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

390

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

caryclark

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

[diff] [blame]

391

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]

392

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]

393

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

394

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

caryclark

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

[diff] [blame]

395

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

caryclark

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

[diff] [blame]

396

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

caryclark

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

[diff] [blame]

397

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

caryclark

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

[diff] [blame]

398

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

caryclark

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

[diff] [blame]

399

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

caryclark

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

[diff] [blame]

400

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

caryclark

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

[diff] [blame]

401

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

402

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

403

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

caryclark

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

[diff] [blame]

404

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

caryclark

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

[diff] [blame]

405

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

406

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

407

return new RegExp(escape, 'i');

408

}

409

410

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

411

var regex = construct_regexp2(pattern);

412

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

413

return true;

414

}

415

regex = construct_regexp2c(pattern);

416

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

417

}

418

419

function endsWith(str, suffix) {

420

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

421

}

422

423

function parse_all(test) {

424

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

425

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

426

var record = [];

427

var recType = REC_TYPE_UNKNOWN;

428

var lastLineNo;

429

var moveX, moveY;

430

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

431

var line = lines[lineNo];

432

if (line.length == 0) {

433

continue;

434

}

435

var opStart = "SkOpSegment::";

436

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

437

line = line.substr(opStart.length);

438

}

439

var angleStart = "SkOpAngle::";

440

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

441

line = line.substr(angleStart.length);

442

}

caryclark

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

[diff] [blame]

443

var coinStart = "SkOpCoincidence::";

444

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

445

line = line.substr(coinStart.length);

446

}

caryclark

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

[diff] [blame]

447

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

caryclark

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

[diff] [blame]

448

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

caryclark

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

[diff] [blame]

449

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

caryclark

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

[diff] [blame]

450

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

caryclark

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

[diff] [blame]

451

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

caryclark

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

[diff] [blame]

452

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

453

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

454

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

455

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

caryclark

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

[diff] [blame]

456

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

caryclark

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

[diff] [blame]

457

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

caryclark

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

[diff] [blame]

458

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

caryclark

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

[diff] [blame]

459

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

460

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

461

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

462

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

463

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

caryclark

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

[diff] [blame]

464

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

caryclark

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

[diff] [blame]

465

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

466

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

467

: REC_TYPE_UNKNOWN;

468

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

469

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

470

if (recType != REC_TYPE_UNKNOWN) {

471

records.push(recType);

472

records.push(lastLineNo);

473

records.push(record);

}

record = [];

recType = type;

lastLineNo = lineNo;

}

var found = false;

switch (recType) {

case REC_TYPE_ACTIVE:

482

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

caryclark

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

[diff] [blame]

483

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

caryclark

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

[diff] [blame]

484

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

caryclark

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

[diff] [blame]

485

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

caryclark

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

[diff] [blame]

486

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

caryclark

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

[diff] [blame]

487

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

caryclark

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

[diff] [blame]

488

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

caryclark

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

[diff] [blame]

489

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

caryclark

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

[diff] [blame]

490

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

caryclark

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

[diff] [blame]

491

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

492

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

caryclark

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

[diff] [blame]

493

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

494

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

caryclark

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

[diff] [blame]

495

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

496

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

caryclark

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

[diff] [blame]

497

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

498

);

499

break;

500

case REC_TYPE_ACTIVE_OP:

501

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

502

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

507

moveX = record[1][0];

508

moveY = record[1][1];

509

found = true;

510

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

511

record[1].unshift(moveY);

512

record[1].unshift(moveX);

513

moveX = record[1][2];

514

moveY = record[1][3];

515

found = true;

516

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

517

record[1].unshift(moveY);

518

record[1].unshift(moveX);

519

moveX = record[1][4];

520

moveY = record[1][5];

521

found = true;

caryclark

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

[diff] [blame]

522

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

523

record[1].unshift(moveY);

524

record[1].unshift(moveX);

525

moveX = record[1][4];

526

moveY = record[1][5];

527

found = true;

caryclark

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

[diff] [blame]

528

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

529

record[1].unshift(moveY);

530

record[1].unshift(moveX);

531

moveX = record[1][6];

532

moveY = record[1][7];

533

found = true;

534

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

535

found = true;

536

} else {

537

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

538

}

539

break;

caryclark

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

[diff] [blame]

540

case REC_TYPE_AFTERPART:

541

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

542

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

caryclark

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

[diff] [blame]

543

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

caryclark

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

[diff] [blame]

544

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

545

break;

caryclark

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

[diff] [blame]

546

case REC_TYPE_ALIGNED:

547

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

548

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

549

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

550

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

551

);

552

break;

caryclark

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

[diff] [blame]

553

case REC_TYPE_ANGLE:

554

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

caryclark

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

[diff] [blame]

555

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

560

case REC_TYPE_COINCIDENCE:

561

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

562

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

563

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

564

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

565

);

566

break;

caryclark

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

[diff] [blame]

567

case REC_TYPE_COMPUTED:

568

found = line == "computed quadratics given"

569

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

570

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

571

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

caryclark

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

[diff] [blame]

572

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

caryclark

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

[diff] [blame]

573

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

574

);

575

break;

576

case REC_TYPE_PATH:

caryclark

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

[diff] [blame]

577

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

578

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

caryclark

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

[diff] [blame]

579

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

caryclark

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

[diff] [blame]

580

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

585

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

caryclark

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

[diff] [blame]

586

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

caryclark

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

[diff] [blame]

587

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

592

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

593

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

594

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

595

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

596

" no intersect LINE_VAL LINE_VAL"

597

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

598

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

599

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

600

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

601

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

602

" no intersect QUAD_VAL LINE_VAL"

603

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

604

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

605

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

606

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

607

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

608

" no intersect QUAD_VAL QUAD_VAL"

caryclark

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

[diff] [blame]

609

caryclark

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

[diff] [blame]

610

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

611

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

612

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

613

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

614

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

615

" no intersect CONIC_VAL LINE_VAL"

caryclark

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

[diff] [blame]

616

617

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

618

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

619

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

620

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

621

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

622

" no intersect CONIC_VAL QUAD_VAL"

623

caryclark

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

[diff] [blame]

624

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

625

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

626

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

627

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

628

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

629

" no intersect CONIC_VAL CONIC_VAL"

caryclark

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

[diff] [blame]

630

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

631

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

632

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

633

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

634

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

635

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

636

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

637

" no intersect CUBIC_VAL LINE_VAL"

638

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

639

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

640

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

641

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

642

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

643

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

644

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

645

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

646

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

647

" no intersect CUBIC_VAL QUAD_VAL"

648

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

649

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

650

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

651

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

652

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

653

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

654

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

655

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

656

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

657

" no intersect CUBIC_VAL CUBIC_VAL"

658

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

659

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

660

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

661

" no self intersect CUBIC_VAL"

);

break;

case REC_TYPE_SORT:

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

666

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

667

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

668

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

669

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

670

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

671

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

672

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

673

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

674

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

675

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

676

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

677

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

678

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

679

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

680

);

681

if (found) {

682

record[1].push(hasDone);

683

record[1].push(hasUnorderable);

684

record[1].push(hasSmall);

685

record[1].push(hasTiny);

686

record[1].push(hasOperand);

687

record[1].push(hasStop);

688

}

689

break;

caryclark

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

[diff] [blame]

690

case REC_TYPE_TOP:

691

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

692

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

693

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

694

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

695

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

696

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

697

);

698

break;

caryclark

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

[diff] [blame]

699

case REC_TYPE_MARK:

700

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

caryclark

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

[diff] [blame]

701

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

702

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

caryclark

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

[diff] [blame]

703

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

704

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

705

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

706

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

caryclark

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

[diff] [blame]

707

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

708

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

709

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

710

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

711

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

712

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

713

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

714

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

715

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

716

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

717

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

718

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

719

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

720

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

721

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

722

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

723

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

724

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

caryclark

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

[diff] [blame]

725

" last segment=IDX span=IDX"

caryclark

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

[diff] [blame]

726

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

caryclark

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

[diff] [blame]

727

" last seg=IDX span=IDX"

728

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

729

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

730

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

731

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

732

);

caryclark

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

[diff] [blame]

733

break;

734

case REC_TYPE_OP:

735

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

736

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

737

found = true;

738

break;

739

}

caryclark

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

[diff] [blame]

740

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

caryclark

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

[diff] [blame]

741

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

caryclark

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

[diff] [blame]

742

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

caryclark

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

[diff] [blame]

743

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

744

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

745

);

746

break;

747

case REC_TYPE_UNKNOWN:

found = true;

break;

}

if (!found) {

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

753

}

754

}

755

if (recType != REC_TYPE_UNKNOWN) {

756

records.push(recType);

757

records.push(lastLineNo);

758

records.push(record);

759

}

760

if (records.length >= 1) {

761

tests[testIndex] = records;

762

testLines[testIndex] = lines;

}

}

function init(test) {

767

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

768

if (!canvas.getContext) return;

769

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

770

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

771

var unscaledWidth = window.innerWidth - 20;

772

var unscaledHeight = window.innerHeight - 20;

773

screenWidth = unscaledWidth;

774

screenHeight = unscaledHeight;

775

canvas.width = unscaledWidth * resScale;

776

canvas.height = unscaledHeight * resScale;

777

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

778

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

779

if (resScale != 1) {

780

ctx.scale(resScale, resScale);

}

xmin = Infinity;

xmax = -Infinity;

ymin = Infinity;

ymax = -Infinity;

caryclark

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

[diff] [blame]

786

hasPath = hasAlignedPath = hasComputedPath = false;

caryclark

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

[diff] [blame]

787

firstActiveSpan = -1;

788

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

789

var recType = test[tIndex];

790

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

791

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

792

throw "stop execution";

793

}

794

var records = test[tIndex + 2];

795

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

796

var fragType = records[recordIndex];

797

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

798

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

799

throw "stop execution";

800

}

801

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]

807

case REC_TYPE_ALIGNED:

808

hasAlignedPath = true;

caryclark

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

[diff] [blame]

809

case REC_TYPE_COMPUTED:

810

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

811

break;

812

}

caryclark

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

[diff] [blame]

813

if (REC_TYPE_COMPUTED == recType) {

814

hasComputedPath = true;

815

}

caryclark

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

[diff] [blame]

816

case REC_TYPE_PATH:

caryclark

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

[diff] [blame]

817

first = 1;

caryclark

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

[diff] [blame]

818

switch (fragType) {

819

case PATH_LINE:

caryclark

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

[diff] [blame]

820

last = 5;

caryclark

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

[diff] [blame]

821

break;

caryclark

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

[diff] [blame]

822

case PATH_CONIC:

caryclark

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

[diff] [blame]

823

case PATH_QUAD:

caryclark

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

[diff] [blame]

824

last = 7;

caryclark

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

[diff] [blame]

825

break;

826

case PATH_CUBIC:

caryclark

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

[diff] [blame]

827

last = 9;

caryclark

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

[diff] [blame]

828

break;

829

default:

caryclark

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

[diff] [blame]

830

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

caryclark

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

[diff] [blame]

831

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

832

throw "stop execution";

833

}

834

if (recType == REC_TYPE_PATH) {

835

hasPath = true;

836

}

837

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]

844

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]

852

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

caryclark

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

[diff] [blame]

853

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

854

throw "stop execution";

855

}

856

if (recType == REC_TYPE_PATH2) {

857

hasPath = true;

858

}

859

break;

caryclark

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

[diff] [blame]

860

case REC_TYPE_ACTIVE:

861

if (firstActiveSpan < 0) {

862

firstActiveSpan = tIndex;

}

first = 1;

switch (fragType) {

case ACTIVE_LINE_SPAN:

867

last = 5;

868

break;

caryclark

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

[diff] [blame]

869

case ACTIVE_CONIC_SPAN:

caryclark

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

[diff] [blame]

870

case ACTIVE_QUAD_SPAN:

871

last = 7;

872

break;

873

case ACTIVE_CUBIC_SPAN:

last = 9;

break;

default:

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

878

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]

888

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

900

throw "stop execution";

901

}

902

break;

caryclark

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

[diff] [blame]

903

case REC_TYPE_AFTERPART:

switch (fragType) {

case PATH_LINE:

last = 4;

break;

caryclark

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

[diff] [blame]

908

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

917

throw "stop execution";

918

}

919

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;

924

break;

925

case INTERSECT_LINE_2:

926

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

927

break;

928

case INTERSECT_LINE_NO:

929

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

930

break;

caryclark

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

[diff] [blame]

931

case INTERSECT_CONIC_LINE:

932

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

933

break;

caryclark

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

[diff] [blame]

934

case INTERSECT_QUAD_LINE:

935

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

936

break;

caryclark

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

[diff] [blame]

937

case INTERSECT_CONIC_LINE_2:

938

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

939

break;

caryclark

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

[diff] [blame]

940

case INTERSECT_QUAD_LINE_2:

941

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

942

break;

caryclark

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

[diff] [blame]

943

case INTERSECT_CONIC_LINE_NO:

944

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

945

break;

caryclark

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

[diff] [blame]

946

case INTERSECT_QUAD_LINE_NO:

947

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

948

break;

caryclark

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

[diff] [blame]

949

case INTERSECT_CONIC:

950

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

951

break;

caryclark

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

[diff] [blame]

952

case INTERSECT_QUAD:

953

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

954

break;

caryclark

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

[diff] [blame]

955

case INTERSECT_CONIC_2:

956

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

957

break;

caryclark

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

[diff] [blame]

958

case INTERSECT_QUAD_2:

959

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

960

break;

caryclark

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

[diff] [blame]

961

case INTERSECT_CONIC_NO:

962

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

963

break;

caryclark

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

[diff] [blame]

964

case INTERSECT_QUAD_NO:

965

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

966

break;

967

case INTERSECT_SELF_CUBIC:

968

first = 1; last = 9;

969

break;

970

case INTERSECT_SELF_CUBIC_NO:

971

first = 0; last = 8;

972

break;

973

case INTERSECT_CUBIC_LINE:

974

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

975

break;

976

case INTERSECT_CUBIC_LINE_2:

977

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

978

break;

979

case INTERSECT_CUBIC_LINE_3:

980

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

981

break;

982

case INTERSECT_CUBIC_LINE_NO:

983

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

984

break;

caryclark

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

[diff] [blame]

985

case INTERSECT_CONIC_QUAD:

986

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

987

break;

988

case INTERSECT_CONIC_QUAD_2:

989

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

990

break;

991

case INTERSECT_CONIC_QUAD_NO:

992

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

993

break;

caryclark

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

[diff] [blame]

994

case INTERSECT_CUBIC_QUAD:

995

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

996

break;

997

case INTERSECT_CUBIC_QUAD_2:

998

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

999

break;

1000

case INTERSECT_CUBIC_QUAD_3:

1001

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

1002

break;

1003

case INTERSECT_CUBIC_QUAD_4:

1004

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

1005

break;

1006

case INTERSECT_CUBIC_QUAD_NO:

1007

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

1008

break;

1009

case INTERSECT_CUBIC:

1010

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

1011

break;

1012

case INTERSECT_CUBIC_2:

1013

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

1014

break;

1015

case INTERSECT_CUBIC_3:

1016

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

1017

break;

1018

case INTERSECT_CUBIC_4:

1019

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

1020

break;

1021

case INTERSECT_CUBIC_NO:

1022

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

1023

break;

1024

default:

1025

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

1026

throw "stop execution";

}

break;

default:

continue;

}

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

1033

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

1034

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

1035

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

1036

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

1037

}

1038

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

1039

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

1040

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

1041

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

1042

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

}

}

}

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

1047

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

1048

var recType = test[tIndex];

1049

var records = test[tIndex + 2];

1050

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

1051

var fragType = records[recordIndex];

1052

var frags = records[recordIndex + 1];

1053

switch (recType) {

1054

case REC_TYPE_ACTIVE_OP:

if (!draw_op) {

break;

}

{

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

1060

curve_extremes(curve, angleBounds);

}

break;

case REC_TYPE_ANGLE:

if (!draw_angle) {

break;

}

caryclark

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

[diff] [blame]

1067

{

caryclark

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

[diff] [blame]

1068

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

1069

curve_extremes(curve, angleBounds);

1070

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

1071

curve_extremes(curve, angleBounds);

1072

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

1073

}

1074

break;

caryclark

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

[diff] [blame]

1075

case REC_TYPE_COINCIDENCE:

1076

if (!draw_coincidence) {

break;

}

{

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

1081

curve_extremes(curve, angleBounds);

1082

}

1083

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

1089

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

1090

curve_extremes(curve, angleBounds);

1091

}

1092

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

1099

curve_extremes(curve, angleBounds);

1100

}

1101

break;

caryclark

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

[diff] [blame]

}

}

}

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

1106

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

1107

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

1108

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

1109

setScale(xmin, xmax, ymin, ymax);

1110

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

caryclark

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

[diff] [blame]

1111

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

caryclark

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

[diff] [blame]

1112

}

1113

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

draw_computed = 0;

}

}

caryclark

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

[diff] [blame]

1118

function curveByIDMatch(test, id, recMatch) {

caryclark

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

[diff] [blame]

1119

var tIndex = -3;

1120

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

caryclark

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

[diff] [blame]

1121

var recType = test[tIndex];

caryclark

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

[diff] [blame]

1122

if (recType == REC_TYPE_OP) {

1123

continue;

1124

}

caryclark

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

[diff] [blame]

1125

if (recType != recMatch) {

caryclark

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

[diff] [blame]

1126

return [];

1127

}

1128

var records = test[tIndex + 2];

1129

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

1130

var fragType = records[recordIndex];

1131

var frags = records[recordIndex + 1];

1132

if (frags[0] == id) {

1133

switch (fragType) {

caryclark

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

[diff] [blame]

1134

case PATH_LINE:

caryclark

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

[diff] [blame]

1135

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

caryclark

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

[diff] [blame]

1136

case PATH_QUAD:

caryclark

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

[diff] [blame]

1137

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

1138

frags[5], frags[6]];

caryclark

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

[diff] [blame]

1139

case PATH_CONIC:

1140

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

1141

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

caryclark

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

[diff] [blame]

1142

case PATH_CUBIC:

caryclark

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

[diff] [blame]

1143

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

1144

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

1145

}

1146

}

1147

}

caryclark

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

[diff] [blame]

}

return [];

}

caryclark

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

[diff] [blame]

1152

function curveByID(test, id) {

1153

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

1154

if (!result.length) {

1155

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]

1161

var tIndex = -3;

1162

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

caryclark

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

[diff] [blame]

1163

var recType = test[tIndex];

caryclark

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

[diff] [blame]

1164

if (recType == REC_TYPE_OP) {

1165

continue;

1166

}

caryclark

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

[diff] [blame]

1167

if (recType != recMatch) {

caryclark

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

[diff] [blame]

1168

return [];

1169

}

1170

var records = test[tIndex + 2];

1171

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

1172

var fragType = records[recordIndex];

1173

var frags = records[recordIndex + 1];

1174

if (frags[0] == id) {

1175

switch (fragType) {

caryclark

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

[diff] [blame]

1176

case PATH_LINE:

caryclark

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

[diff] [blame]

1177

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

caryclark

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

[diff] [blame]

1178

case PATH_QUAD:

caryclark

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

[diff] [blame]

1179

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

1180

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

caryclark

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

[diff] [blame]

1181

case PATH_CONIC:

1182

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

1183

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

caryclark

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

[diff] [blame]

1184

case PATH_CUBIC:

caryclark

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

[diff] [blame]

1185

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

1186

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

1187

}

1188

}

1189

}

caryclark

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

[diff] [blame]

}

return [];

}

caryclark

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

[diff] [blame]

1194

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

1195

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

1196

if (!result.length) {

1197

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]

1203

var tIndex = 0;

caryclark

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

[diff] [blame]

1204

while (tIndex < test.length) {

1205

var recType = test[tIndex];

caryclark

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

[diff] [blame]

1206

if (recType != recMatch) {

caryclark

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

[diff] [blame]

1207

++tIndex;

1208

continue;

caryclark

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

[diff] [blame]

1209

}

1210

var records = test[tIndex + 2];

1211

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

1212

var fragType = records[recordIndex];

1213

var frags = records[recordIndex + 1];

caryclark

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

[diff] [blame]

1214

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

1215

continue;

1216

}

caryclark

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

[diff] [blame]

1217

switch (fragType) {

caryclark

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

[diff] [blame]

1218

case PATH_LINE:

caryclark

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

[diff] [blame]

1219

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

1220

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

1221

continue;

1222

}

1223

return frags[0];

caryclark

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

[diff] [blame]

1224

case PATH_QUAD:

caryclark

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

[diff] [blame]

1225

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

1226

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

1227

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

1228

continue;

1229

}

1230

return frags[0];

caryclark

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

[diff] [blame]

1231

case PATH_CONIC:

1232

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

1233

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

1234

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

1235

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

1236

continue;

1237

}

1238

return frags[0];

caryclark

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

[diff] [blame]

1239

case PATH_CUBIC:

caryclark

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

[diff] [blame]

1240

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

1241

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

1242

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

1243

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

1254

function idByCurve(test, frag, type) {

1255

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

1256

if (!result.length) {

1257

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

}

return result;

}

caryclark

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

[diff] [blame]

1262

function curve_extremes(curve, bounds) {

caryclark

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

[diff] [blame]

1263

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

caryclark

ed0935a

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

[diff] [blame]

1264

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

caryclark

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

[diff] [blame]

1265

var x = curve[index];

1266

var y = curve[index + 1];

1267

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

1268

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

1269

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

1270

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

}

}

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

1275

var srcWidth = x1 - x0;

1276

var srcHeight = y1 - y0;

1277

var usableWidth = screenWidth;

1278

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

1279

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

1280

usableWidth -= (xDigits + yDigits) * 10;

1281

usableWidth -= decimal_places * 10;

if (draw_legend) {

usableWidth -= 40;

}

var hscale = usableWidth / srcWidth;

1286

var vscale = screenHeight / srcHeight;

1287

scale = Math.min(hscale, vscale);

1288

var invScale = 1 / scale;

1289

var sxmin = x0 - invScale * 5;

1290

var symin = y0 - invScale * 10;

1291

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

1292

var symax = y1 + invScale * 10;

1293

srcWidth = sxmax - sxmin;

1294

srcHeight = symax - symin;

1295

hscale = usableWidth / srcWidth;

1296

vscale = screenHeight / srcHeight;

1297

scale = Math.min(hscale, vscale);

srcLeft = sxmin;

srcTop = symin;

}

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

1303

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

1304

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

1305

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

1306

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

1307

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

1308

var _dist = dist * scale;

1309

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

1310

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

1311

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

var divisor = 4;

var endDist;

do {

var ends = [];

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

1317

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

1318

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

ends.push(px);

ends.push(py);

}

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

1323

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

1324

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

1337

ctx.beginPath();

1338

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

1339

ctx.stroke();

1340

var saveAlign = ctx.textAlign;

1341

var saveStyle = ctx.fillStyle;

1342

var saveFont = ctx.font;

1343

ctx.textAlign = "center";

1344

ctx.fillStyle = "black";

1345

ctx.font = "normal 24px Arial";

1346

divisor *= 0.8;

1347

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

1348

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

1349

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

1350

var _px = (px - srcLeft) * scale;

1351

var _py = (py - srcTop) * scale;

1352

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

1353

}

1354

ctx.textAlign = saveAlign;

1355

ctx.fillStyle = saveStyle;

ctx.font = saveFont;

}

function drawPoint(px, py, end) {

caryclark

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

[diff] [blame]

1360

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

1361

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

caryclark

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

[diff] [blame]

1362

var x = drawnPts[pts];

1363

var y = drawnPts[pts + 1];

1364

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

return;

}

}

drawnPts.push(px);

drawnPts.push(py);

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

1371

var _px = (px - srcLeft) * scale;

1372

var _py = (py - srcTop) * scale;

1373

ctx.beginPath();

1374

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

1383

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

}

}

caryclark

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

[diff] [blame]

1387

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]

1401

function drawPoints(ptArray, curveType, drawControls) {

caryclark

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

[diff] [blame]

1402

var count = coordCount(curveType);

caryclark

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

[diff] [blame]

1403

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

1404

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

1405

continue;

1406

}

1407

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

}

}

function drawControlLines(curve, curveType, drawEnd) {

1412

if (curveType == PATH_LINE) {

1413

return;

1414

}

1415

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

1416

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

1417

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

1418

if (curveType == PATH_CUBIC) {

1419

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

1420

if (drawEnd > 1) {

1421

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

1422

if (drawEnd > 2) {

1423

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

1424

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

1425

}

1426

}

1427

} else if (drawEnd > 1) {

1428

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

1439

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

break;

case PATH_QUAD:

var one_t = 1 - t;

var a = one_t * one_t;

1444

var b = 2 * one_t * t;

1445

var c = t * t;

1446

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

1447

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

1448

break;

caryclark

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

[diff] [blame]

1449

case PATH_CONIC:

1450

var one_t = 1 - t;

1451

var a = one_t * one_t;

1452

var b = 2 * one_t * t;

1453

var c = t * t;

1454

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

1455

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

1456

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

1457

xy.x /= d;

1458

xy.y /= d;

1459

break;

caryclark

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

[diff] [blame]

1460

case PATH_CUBIC:

1461

var one_t = 1 - t;

1462

var one_t2 = one_t * one_t;

1463

var a = one_t2 * one_t;

1464

var b = 3 * one_t2 * t;

1465

var t2 = t * t;

1466

var c = 3 * one_t * t2;

1467

var d = t2 * t;

1468

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

1469

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]

1474

caryclark

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

[diff] [blame]

1475

function drawPointAtT(curve, curveType) {

1476

var x, y;

1477

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

1478

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

1479

if (!draw_intersectT) {

1480

return;

1481

}

1482

ctx.fillStyle = "red";

1483

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

1484

}

1485

1486

function drawTAtPointUp(px, py, t) {

1487

var label = t.toFixed(decimal_places);

1488

var _px = (px - srcLeft)* scale;

1489

var _py = (py - srcTop) * scale;

1490

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

1491

}

1492

1493

function drawTAtPointDown(px, py, t) {

1494

var label = t.toFixed(decimal_places);

1495

var _px = (px - srcLeft)* scale;

1496

var _py = (py - srcTop) * scale;

1497

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

1498

}

1499

1500

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

1501

if (collect_bounds) {

1502

if (focus_enabled) {

1503

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

1504

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

1505

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

1506

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

}

return true;

}

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

1511

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

1512

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

1524

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

return;

}

ctx.beginPath();

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

1529

(y1 - srcTop) * scale);

1530

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

1531

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

1548

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,

1558

(ay - srcTop) * scale);

1559

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

1560

(by - srcTop) * scale);

ctx.stroke();

}

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

1565

if (collect_bounds) {

1566

if (focus_enabled) {

1567

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

1568

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

1569

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

1570

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

}

return true;

}

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

1575

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

1576

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

1577

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

1591

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

return;

}

ctx.beginPath();

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

1596

(y1 - srcTop) * scale);

1597

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

1598

(y2 - srcTop) * scale,

1599

(x3 - srcLeft) * scale,

1600

(y3 - srcTop) * scale);

ctx.stroke();

}

function interp(A, B, t) {

1605

return A + (B - A) * t;

1606

}

1607

1608

function interp_quad_coords(x1, x2, x3, t)

1609

{

1610

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

1611

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

1612

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

return abc;

}

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

1617

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

1618

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

1619

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

1620

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

1621

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

1622

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

1623

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

1624

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

1625

var array = [

1626

ax, ay, bx, by, cx, cy

];

return array;

}

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

1632

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,

1644

(ay - srcTop) * scale);

1645

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

1646

(by - srcTop) * scale,

1647

(cx - srcLeft) * scale,

1648

(cy - srcTop) * scale);

ctx.stroke();

}

caryclark

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

[diff] [blame]

1652

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

1653

if (collect_bounds) {

1654

if (focus_enabled) {

1655

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

1656

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

1657

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

1658

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

}

return true;

}

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

1663

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

caryclark

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

[diff] [blame]

1664

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

1665

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

caryclark

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

[diff] [blame]

1666

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

return true;

}

}

drawnConics.push(x1);

1671

drawnConics.push(y1);

1672

drawnConics.push(x2);

1673

drawnConics.push(y2);

1674

drawnConics.push(x3);

1675

drawnConics.push(y3);

drawnCubics.push(w);

return false;

}

var kMaxConicToQuadPOW2 = 5;

1681

1682

function computeQuadPOW2(curve, tol) {

1683

var a = curve[6] - 1;

1684

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

1685

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

1686

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

1687

1688

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

1689

var pow2;

1690

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

if (error <= tol) {

break;

}

error *= 0.25;

}

return pow2;

}

function subdivide_w_value(w) {

1700

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

1701

}

1702

1703

function chop(curve, part1, part2) {

1704

var w = curve[6];

1705

var scale = 1 / (1 + w);

1706

part1[0] = curve[0];

1707

part1[1] = curve[1];

1708

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

1709

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

1710

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

1711

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

1712

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

1713

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

1714

part2[4] = curve[4];

1715

part2[5] = curve[5];

1716

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

1717

}

1718

1719

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

1727

chop(curve, part1, part2);

1728

--level;

1729

subdivide(part1, level, pts);

1730

subdivide(part2, level, pts);

}

}

function chopIntoQuadsPOW2(curve, pow2, pts) {

1735

subdivide(curve, pow2, pts);

return 1 << pow2;

}

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

1740

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

return;

}

ctx.beginPath();

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

1745

(y1 - srcTop) * scale);

1746

var tol = 1 / scale;

1747

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

1748

var pow2 = computeQuadPOW2(curve, tol);

1749

var pts = [];

1750

chopIntoQuadsPOW2(curve, pow2, pts);

1751

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

1752

ctx.quadraticCurveTo(

1753

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

1754

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

}

ctx.stroke();

}

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

1760

var src2w = x2 * w;

1761

var C = x1;

1762

var A = x3 - 2 * src2w + C;

1763

var B = 2 * (src2w - C);

1764

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;

1773

}

1774

1775

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

1776

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

1777

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

1778

var az = conic_eval_denominator(w, t1);

1779

var midT = (t1 + t2) / 2;

1780

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

1781

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

1782

var dz = conic_eval_denominator(w, midT);

1783

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

1784

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

1785

var cz = conic_eval_denominator(w, t2);

1786

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

1787

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

1788

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

1789

var dt = t2 - t1;

1790

var dt_1 = 1 - dt;

caryclark

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

[diff] [blame]

1791

var array = [

caryclark

ed0935a

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

[diff] [blame]

1792

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

caryclark

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

[diff] [blame]

1793

];

caryclark

ed0935a

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

[diff] [blame]

1794

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

1795

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

1796

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

1797

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

1798

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

1799

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

1800

array[6] = partW;

caryclark

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

[diff] [blame]

1801

return array;

1802

}

caryclark

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

[diff] [blame]

1803

caryclark

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

[diff] [blame]

1804

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

1805

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

1814

}

1815

caryclark

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

[diff] [blame]

1816

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

1817

if (collect_bounds) {

1818

if (focus_enabled) {

1819

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

1820

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

1821

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

1822

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

}

return true;

}

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

1827

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

caryclark

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

[diff] [blame]

1828

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

1829

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

caryclark

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

[diff] [blame]

1830

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

return true;

}

}

drawnCubics.push(x1);

1835

drawnCubics.push(y1);

1836

drawnCubics.push(x2);

1837

drawnCubics.push(y2);

1838

drawnCubics.push(x3);

1839

drawnCubics.push(y3);

1840

drawnCubics.push(x4);

1841

drawnCubics.push(y4);

return false;

}

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

1846

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

return;

}

ctx.beginPath();

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

1851

(y1 - srcTop) * scale);

1852

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

1853

(y2 - srcTop) * scale,

1854

(x3 - srcLeft) * scale,

1855

(y3 - srcTop) * scale,

1856

(x4 - srcLeft) * scale,

1857

(y4 - srcTop) * scale);

ctx.stroke();

}

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

1862

{

1863

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

1864

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

1865

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

1866

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

1867

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

1868

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

return abcd;

}

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

1873

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

1874

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

1875

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

1876

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

1877

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

1878

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

1879

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

1880

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

1881

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

1882

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

1883

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

1884

var ny = fy * 27 - ay - dy * 8;

1885

var bx = (mx * 2 - nx) / 18;

1886

var by = (my * 2 - ny) / 18;

1887

var cx = (nx * 2 - mx) / 18;

1888

var cy = (ny * 2 - my) / 18;

1889

var array = [

1890

ax, ay, bx, by, cx, cy, dx, dy

1891

];

1892

return array;

1893

}

caryclark

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

[diff] [blame]

1894

caryclark

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

[diff] [blame]

1895

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

1896

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,

1910

(ay - srcTop) * scale);

1911

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

1912

(by - srcTop) * scale,

1913

(cx - srcLeft) * scale,

1914

(cy - srcTop) * scale,

1915

(dx - srcLeft) * scale,

1916

(dy - srcTop) * scale);

ctx.stroke();

}

function drawCurve(c) {

1921

switch (c.length) {

1922

case 4:

1923

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

1924

break;

1925

case 6:

1926

drawQuad(c[0], c[1], c[2], c[3], c[4], c[5]);

1927

break;

caryclark

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

[diff] [blame]

1928

case 7:

1929

drawConicWithQuads(c[0], c[1], c[2], c[3], c[4], c[5], c[6]);

1930

break;

caryclark

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

[diff] [blame]

1931

case 8:

1932

drawCubic(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]);

break;

}

}

function boundsWidth(pts) {

1938

var min = pts[0];

1939

var max = pts[0];

caryclark

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

[diff] [blame]

1940

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

1941

for (var idx = 2; idx < length; idx += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1942

min = Math.min(min, pts[idx]);

1943

max = Math.max(max, pts[idx]);

}

return max - min;

}

function boundsHeight(pts) {

1949

var min = pts[1];

1950

var max = pts[1];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1951

var length = pts.length == 7 ? 6 : pts.length;

1952

for (var idx = 3; idx < length; idx += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1953

min = Math.min(min, pts[idx]);

1954

max = Math.max(max, pts[idx]);

}

return max - min;

}

function tangent(pts) {

1960

var dx = pts[2] - pts[0];

1961

var dy = pts[3] - pts[1];

1962

if (dx == 0 && dy == 0 && pts.length > 4) {

1963

dx = pts[4] - pts[0];

1964

dy = pts[5] - pts[1];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

1965

if (dx == 0 && dy == 0 && pts.length == 8) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

1966

dx = pts[6] - pts[0];

1967

dy = pts[7] - pts[1];

1968

}

1969

}

1970

return Math.atan2(-dy, dx);

1971

}

1972

1973

function hodograph(cubic) {

1974

var hodo = [];

1975

hodo[0] = 3 * (cubic[2] - cubic[0]);

1976

hodo[1] = 3 * (cubic[3] - cubic[1]);

1977

hodo[2] = 3 * (cubic[4] - cubic[2]);

1978

hodo[3] = 3 * (cubic[5] - cubic[3]);

1979

hodo[4] = 3 * (cubic[6] - cubic[4]);

1980

hodo[5] = 3 * (cubic[7] - cubic[5]);

return hodo;

}

function hodograph2(cubic) {

1985

var quad = hodograph(cubic);

1986

var hodo = [];

1987

hodo[0] = 2 * (quad[2] - quad[0]);

1988

hodo[1] = 2 * (quad[3] - quad[1]);

1989

hodo[2] = 2 * (quad[4] - quad[2]);

1990

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];

2017

}

2018

2019

function add_valid_ts(s, realRoots, t) {

2020

var foundRoots = 0;

2021

for (var index = 0; index < realRoots; ++index) {

2022

var tValue = s[index];

2023

if (tValue >= 0 && tValue <= 1) {

2024

for (var idx2 = 0; idx2 < foundRoots; ++idx2) {

2025

if (t[idx2] != tValue) {

2026

t[foundRoots++] = tValue;

}

}

}

}

return foundRoots;

}

function quadraticRootsValidT(a, b, c, t) {

2035

var s = [];

2036

var realRoots = quadraticRootsReal(A, B, C, s);

2037

var foundRoots = add_valid_ts(s, realRoots, t);

2038

return foundRoots != 0;

2039

}

2040

2041

function find_cubic_inflections(cubic, tValues) {

2042

var Ax = src[2] - src[0];

2043

var Ay = src[3] - src[1];

2044

var Bx = src[4] - 2 * src[2] + src[0];

2045

var By = src[5] - 2 * src[3] + src[1];

2046

var Cx = src[6] + 3 * (src[2] - src[4]) - src[0];

2047

var Cy = src[7] + 3 * (src[3] - src[5]) - src[1];

2048

return quadraticRootsValidT(Bx * Cy - By * Cx, (Ax * Cy - Ay * Cx),

2049

Ax * By - Ay * Bx, tValues);

2050

}

2051

2052

function dxy_at_t(curve, type, t) {

2053

var dxy = {};

2054

if (type == PATH_QUAD) {

var a = t - 1;

var b = 1 - 2 * t;

var c = t;

dxy.x = a * curve[0] + b * curve[2] + c * curve[4];

2059

dxy.y = a * curve[1] + b * curve[3] + c * curve[5];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2060

} else if (type == PATH_CONIC) {

2061

var p20x = curve[4] - curve[0];

2062

var p20y = curve[5] - curve[1];

2063

var p10xw = (curve[2] - curve[0]) * curve[6];

2064

var p10yw = (curve[3] - curve[1]) * curve[6];

2065

var coeff0x = curve[6] * p20x - p20x;

2066

var coeff0y = curve[6] * p20y - p20y;

2067

var coeff1x = p20x - 2 * p10xw;

2068

var coeff1y = p20y - 2 * p10yw;

2069

dxy.x = t * (t * coeff0x + coeff1x) + p10xw;

2070

dxy.y = t * (t * coeff0y + coeff1y) + p10yw;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2071

} else if (type == PATH_CUBIC) {

var one_t = 1 - t;

var a = curve[0];

var b = curve[2];

var c = curve[4];

var d = curve[6];

dxy.x = 3 * ((b - a) * one_t * one_t + 2 * (c - b) * t * one_t + (d - c) * t * t);

a = curve[1];

b = curve[3];

c = curve[5];

d = curve[7];

dxy.y = 3 * ((b - a) * one_t * one_t + 2 * (c - b) * t * one_t + (d - c) * t * t);

}

return dxy;

}

function drawLabel(num, px, py) {

2088

ctx.beginPath();

2089

ctx.arc(px, py, 8, 0, Math.PI*2, true);

2090

ctx.closePath();

2091

ctx.strokeStyle = "rgba(0,0,0, 0.4)";

2092

ctx.lineWidth = num == 0 || num == 3 ? 2 : 1;

2093

ctx.stroke();

2094

ctx.fillStyle = "black";

2095

ctx.font = "normal 10px Arial";

2096

// ctx.rotate(0.001);

2097

ctx.fillText(num, px - 2, py + 3);

2098

// ctx.rotate(-0.001);

2099

}

2100

2101

function drawLabelX(ymin, num, loc) {

2102

var px = (loc - srcLeft) * scale;

2103

var py = (ymin - srcTop) * scale - 20;

2104

drawLabel(num, px, py);

2105

}

2106

2107

function drawLabelY(xmin, num, loc) {

2108

var px = (xmin - srcLeft) * scale - 20;

2109

var py = (loc - srcTop) * scale;

2110

drawLabel(num, px, py);

2111

}

2112

2113

function drawHodoOrigin(hx, hy, hMinX, hMinY, hMaxX, hMaxY) {

2114

ctx.beginPath();

2115

ctx.moveTo(hx, hy - 100);

2116

ctx.lineTo(hx, hy);

2117

ctx.strokeStyle = hMinY < 0 ? "green" : "blue";

ctx.stroke();

ctx.beginPath();

ctx.moveTo(hx, hy);

ctx.lineTo(hx, hy + 100);

2122

ctx.strokeStyle = hMaxY > 0 ? "green" : "blue";

2123

ctx.stroke();

2124

ctx.beginPath();

2125

ctx.moveTo(hx - 100, hy);

2126

ctx.lineTo(hx, hy);

2127

ctx.strokeStyle = hMinX < 0 ? "green" : "blue";

ctx.stroke();

ctx.beginPath();

ctx.moveTo(hx, hy);

ctx.lineTo(hx + 100, hy);

2132

ctx.strokeStyle = hMaxX > 0 ? "green" : "blue";

ctx.stroke();

}

function scalexy(x, y, mag) {

2137

var length = Math.sqrt(x * x + y * y);

return mag / length;

}

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2141

function drawArrow(x, y, dx, dy, s) {

2142

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);

2147

x += dx;

2148

y += dy;

2149

ctx.lineTo((x - srcLeft) * scale, (y - srcTop) * scale);

2150

dx /= 10;

2151

dy /= 10;

2152

ctx.lineTo((x - dy - srcLeft) * scale, (y + dx - srcTop) * scale);

2153

ctx.lineTo((x + dx * 2 - srcLeft) * scale, (y + dy * 2 - srcTop) * scale);

2154

ctx.lineTo((x + dy - srcLeft) * scale, (y - dx - srcTop) * scale);

2155

ctx.lineTo((x - srcLeft) * scale, (y - srcTop) * scale);

2156

ctx.strokeStyle = "rgba(0,75,0, 0.4)";

ctx.stroke();

}

function x_at_t(curve, t) {

2161

var one_t = 1 - t;

2162

if (curve.length == 4) {

2163

return one_t * curve[0] + t * curve[2];

2164

}

2165

var one_t2 = one_t * one_t;

2166

var t2 = t * t;

2167

if (curve.length == 6) {

2168

return one_t2 * curve[0] + 2 * one_t * t * curve[2] + t2 * curve[4];

2169

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2170

if (curve.length == 7) {

2171

return (one_t2 * curve[0] + 2 * one_t * t * curve[2] * curve[6] + t2 * curve[4])

2172

/ (one_t2 +2 * one_t * t * curve[6] + t2);

2173

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2174

var a = one_t2 * one_t;

2175

var b = 3 * one_t2 * t;

2176

var c = 3 * one_t * t2;

2177

var d = t2 * t;

2178

return a * curve[0] + b * curve[2] + c * curve[4] + d * curve[6];

2179

}

2180

2181

function y_at_t(curve, t) {

2182

var one_t = 1 - t;

2183

if (curve.length == 4) {

2184

return one_t * curve[1] + t * curve[3];

2185

}

2186

var one_t2 = one_t * one_t;

2187

var t2 = t * t;

2188

if (curve.length == 6) {

2189

return one_t2 * curve[1] + 2 * one_t * t * curve[3] + t2 * curve[5];

2190

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2191

if (curve.length == 7) {

2192

return (one_t2 * curve[1] + 2 * one_t * t * curve[3] * curve[6] + t2 * curve[5])

2193

/ (one_t2 +2 * one_t * t * curve[6] + t2);

2194

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2195

var a = one_t2 * one_t;

2196

var b = 3 * one_t2 * t;

2197

var c = 3 * one_t * t2;

2198

var d = t2 * t;

2199

return a * curve[1] + b * curve[3] + c * curve[5] + d * curve[7];

2200

}

2201

2202

function drawOrder(curve, label) {

2203

var px = x_at_t(curve, 0.75);

2204

var py = y_at_t(curve, 0.75);

2205

var _px = (px - srcLeft) * scale;

2206

var _py = (py - srcTop) * scale;

2207

ctx.beginPath();

2208

ctx.arc(_px, _py, 15, 0, Math.PI * 2, true);

2209

ctx.closePath();

2210

ctx.fillStyle = "white";

2211

ctx.fill();

2212

if (label == 'L') {

2213

ctx.strokeStyle = "rgba(255,0,0, 1)";

2214

ctx.fillStyle = "rgba(255,0,0, 1)";

2215

} else {

2216

ctx.strokeStyle = "rgba(0,0,255, 1)";

2217

ctx.fillStyle = "rgba(0,0,255, 1)";

2218

}

2219

ctx.stroke();

2220

ctx.font = "normal 16px Arial";

2221

ctx.textAlign = "center";

2222

ctx.fillText(label, _px, _py + 5);

2223

ctx.font = "normal 10px Arial";

2224

}

2225

2226

function drawID(curve, id) {

2227

var px = x_at_t(curve, 0.5);

2228

var py = y_at_t(curve, 0.5);

2229

var _px = (px - srcLeft) * scale;

2230

var _py = (py - srcTop) * scale;

2231

draw_id_at(id, _px, _py);

2232

}

2233

2234

function draw_id_at(id, _px, _py) {

2235

ctx.beginPath();

2236

ctx.arc(_px, _py, 15, 0, Math.PI * 2, true);

2237

ctx.closePath();

2238

ctx.fillStyle = "white";

2239

ctx.fill();

2240

ctx.strokeStyle = "rgba(127,127,0, 1)";

2241

ctx.fillStyle = "rgba(127,127,0, 1)";

2242

ctx.stroke();

2243

ctx.font = "normal 16px Arial";

2244

ctx.textAlign = "center";

2245

ctx.fillText(id, _px, _py + 5);

2246

ctx.font = "normal 10px Arial";

2247

}

2248

2249

function drawLinePartialID(id, x1, y1, x2, y2, t1, t2) {

2250

var curve = [x1, y1, x2, y2];

2251

drawCurvePartialID(id, curve, t1, t2);

2252

}

2253

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2254

function drawLineID(id, x1, y1, x2, y2) {

2255

drawLinePartialID(id, x1, y1, x2, y2, 0, 1);

2256

}

2257

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2258

function drawQuadPartialID(id, x1, y1, x2, y2, x3, y3, t1, t2) {

2259

var curve = [x1, y1, x2, y2, x3, y3];

2260

drawCurvePartialID(id, curve, t1, t2);

2261

}

2262

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2263

function drawQuadID(id, x1, y1, x2, y2, x3, y3) {

2264

drawQuadPartialID(id, x1, y1, x2, y2, x3, y3, 0, 1);

2265

}

2266

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2267

function drawConicPartialID(id, x1, y1, x2, y2, x3, y3, w, t1, t2) {

2268

var curve = [x1, y1, x2, y2, x3, y3, w];

2269

drawCurvePartialID(id, curve, t1, t2);

2270

}

2271

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2272

function drawConicID(id, x1, y1, x2, y2, x3, y3, w) {

2273

drawConicPartialID(id, x1, y1, x2, y2, x3, y3, w, 0, 1);

2274

}

2275

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2276

function drawCubicPartialID(id, x1, y1, x2, y2, x3, y3, x4, y4, t1, t2) {

2277

var curve = [x1, y1, x2, y2, x3, y3, x4, y4];

2278

drawCurvePartialID(id, curve, t1, t2);

2279

}

2280

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2281

function drawCubicID(id, x1, y1, x2, y2, x3, y3, x4, y4) {

2282

drawCubicPartialID(id, x1, y1, x2, y2, x3, y3, x4, y4, 0, 1);

2283

}

2284

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2285

function drawCurvePartialID(id, curve, t1, t2) {

2286

var px = x_at_t(curve, (t1 + t2) / 2);

2287

var py = y_at_t(curve, (t1 + t2) / 2);

2288

var _px = (px - srcLeft) * scale;

2289

var _py = (py - srcTop) * scale;

2290

draw_id_at(id, _px, _py);

2291

}

2292

2293

function drawCurveSpecials(test, curve, type) {

2294

if (pt_labels) {

2295

drawPoints(curve, type, pt_labels == 2);

2296

}

2297

if (control_lines != 0) {

2298

drawControlLines(curve, type, control_lines);

2299

}

2300

if (curve_t) {

2301

drawPointAtT(curve, type);

2302

}

2303

if (draw_midpoint) {

2304

var mid = pointAtT(curve, type, 0.5);

2305

drawPoint(mid.x, mid.y, true);

2306

}

2307

if (draw_id) {

2308

var id = idByCurve(test, curve, type);

if (id >= 0) {

drawID(curve, id);

}

}

if (type == PATH_LINE) {

2314

return;

2315

}

2316

if (draw_deriviatives > 0) {

2317

var d = dxy_at_t(curve, type, 0);

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2318

drawArrow(curve[0], curve[1], d.x, d.y, 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2319

if (draw_deriviatives == 2) {

2320

d = dxy_at_t(curve, type, 1);

2321

if (type == PATH_CUBIC) {

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2322

drawArrow(curve[6], curve[7], d.x, d.y, 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2323

} else {

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2324

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);

2329

d = dxy_at_t(curve, type, 0.5);

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2330

drawArrow(mid.x, mid.y, d.x, d.y, 1);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2331

}

2332

}

2333

if (type != PATH_CUBIC) {

2334

return;

2335

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2336

if (draw_sequence) {

2337

var ymin = Math.min(curve[1], curve[3], curve[5], curve[7]);

2338

for (var i = 0; i < 8; i+= 2) {

2339

drawLabelX(ymin, i >> 1, curve[i]);

2340

}

2341

var xmin = Math.min(curve[0], curve[2], curve[4], curve[6]);

2342

for (var i = 1; i < 8; i+= 2) {

2343

drawLabelY(xmin, i >> 1, curve[i]);

}

}

}

function logCurves(test) {

2349

for (curves in test) {

2350

var curve = test[curves];

dumpCurve(curve);

}

}

function curveToString(curve) {

2356

var str = "{{";

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2357

var length = curve.length == 7 ? 6 : curve.length;

2358

if (curve.length == 7) {

2359

str += "{";

2360

}

2361

for (i = 0; i < length; i += 2) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2362

str += curve[i].toFixed(decimal_places) + "," + curve[i + 1].toFixed(decimal_places);

2363

if (i < curve.length - 2) {

2364

str += "}, {";

2365

}

2366

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2367

str += "}";

2368

if (curve.length == 7) {

2369

str += "}, " + curve[6].toFixed(decimal_places);

2370

}

2371

str += "}";

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

return str;

}

function dumpCurve(curve) {

2376

console.log(curveToString(curve));

2377

}

2378

2379

function draw(test, lines, title) {

2380

ctx.fillStyle = "rgba(0,0,0, 0.1)";

2381

ctx.font = "normal 50px Arial";

2382

ctx.textAlign = "left";

2383

ctx.fillText(title, 50, 50);

2384

ctx.font = "normal 10px Arial";

2385

ctx.lineWidth = "1.001"; "0.999";

2386

var secondPath = test.length;

var closeCount = 0;

logStart = -1;

logRange = 0;

// find last active rec type at this step

2391

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]

2396

var lastCoin = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2397

var lastSect = 0;

2398

var lastSort = 0;

2399

var lastMark = 0;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2400

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]

2407

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]

2412

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]

2417

topMax = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2418

markMax = 0;

2419

lastIndex = test.length - 3;

2420

for (var tIndex = 0; tIndex < test.length; tIndex += 3) {

2421

var recType = test[tIndex];

2422

if (!typeof recType == 'number' || recType < REC_TYPE_UNKNOWN || recType > REC_TYPE_LAST) {

2423

console.log("unknown rec type: " + recType);

2424

throw "stop execution";

2425

}

2426

// if (curType == recType && curType != REC_TYPE_ADD) {

2427

// continue;

2428

// }

2429

var inStepRange = step_limit == 0 || curStep < step_limit;

2430

curType = recType;

2431

if (recType == REC_TYPE_OP) {

hasOp = true;

continue;

}

if (recType == REC_TYPE_UNKNOWN) {

2436

// these types do not advance step

2437

continue;

2438

}

2439

var bumpStep = false;

2440

var records = test[tIndex + 2];

2441

var fragType = records[0];

2442

if (recType == REC_TYPE_ADD) {

2443

if (records.length != 2) {

2444

console.log("expect only two elements: " + records.length);

2445

throw "stop execution";

2446

}

2447

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) {

2459

secondPath = tIndex;

2460

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2461

if (recType == REC_TYPE_PATH2 && hasOp) {

2462

secondPath = tIndex;

2463

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2464

if (recType == REC_TYPE_ACTIVE) {

2465

++activeMax;

2466

if (!draw_active || !inStepRange) {

continue;

}

lastActive = tIndex;

++activeCount;

bumpStep = true;

}

if (recType == REC_TYPE_ACTIVE_OP) {

2474

++opMax;

2475

if (!draw_op || !inStepRange) {

continue;

}

lastOp = tIndex;

++opCount;

bumpStep = true;

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2482

if (recType == REC_TYPE_AFTERPART) {

2483

if (draw_angle != 3 || !inStepRange) {

continue;

}

lastAngle = tIndex;

++angleCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2490

if (recType == REC_TYPE_ANGLE) {

2491

++angleMax;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2492

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]

2499

if (recType == REC_TYPE_COINCIDENCE) {

2500

++coinMax;

2501

if (!draw_coincidence || !inStepRange) {

continue;

}

lastCoin = tIndex;

++coinCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2508

if (recType == REC_TYPE_SECT) {

2509

if (records.length != 2) {

2510

console.log("expect only two elements: " + records.length);

2511

throw "stop execution";

}

++sectMax;

var sectBump = 1;

switch (fragType) {

case INTERSECT_LINE:

case INTERSECT_QUAD_LINE:

2518

case INTERSECT_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2519

case INTERSECT_CONIC_LINE:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2520

case INTERSECT_CONIC_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2521

case INTERSECT_CONIC:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2522

case INTERSECT_SELF_CUBIC:

2523

case INTERSECT_CUBIC_LINE:

2524

case INTERSECT_CUBIC_QUAD:

2525

case INTERSECT_CUBIC:

2526

sectBump = 1;

2527

break;

2528

case INTERSECT_LINE_2:

2529

case INTERSECT_QUAD_LINE_2:

2530

case INTERSECT_QUAD_2:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2531

case INTERSECT_CONIC_LINE_2:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2532

case INTERSECT_CONIC_QUAD_2:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2533

case INTERSECT_CONIC_2:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2534

case INTERSECT_CUBIC_LINE_2:

2535

case INTERSECT_CUBIC_QUAD_2:

2536

case INTERSECT_CUBIC_2:

2537

sectBump = 2;

2538

break;

2539

case INTERSECT_LINE_NO:

2540

case INTERSECT_QUAD_LINE_NO:

2541

case INTERSECT_QUAD_NO:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2542

case INTERSECT_CONIC_LINE_NO:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2543

case INTERSECT_CONIC_QUAD_NO:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2544

case INTERSECT_CONIC_NO:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2545

case INTERSECT_SELF_CUBIC_NO:

2546

case INTERSECT_CUBIC_LINE_NO:

2547

case INTERSECT_CUBIC_QUAD_NO:

2548

case INTERSECT_CUBIC_NO:

2549

sectBump = 0;

2550

break;

2551

case INTERSECT_CUBIC_LINE_3:

2552

case INTERSECT_CUBIC_QUAD_3:

2553

case INTERSECT_CUBIC_3:

2554

sectBump = 3;

2555

break;

2556

case INTERSECT_CUBIC_QUAD_4:

2557

case INTERSECT_CUBIC_4:

sectBump = 4;

break;

default:

console.log("missing case " + records.length);

2562

throw "stop execution";

2563

}

2564

sectMax2 += sectBump;

2565

if (draw_intersection <= 1 || !inStepRange) {

continue;

}

lastSect = tIndex;

sectCount += sectBump;

2570

bumpStep = true;

2571

}

2572

if (recType == REC_TYPE_SORT) {

2573

++sortMax;

2574

if (!draw_sort || !inStepRange) {

continue;

}

lastSort = tIndex;

++sortCount;

bumpStep = true;

}

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2581

if (recType == REC_TYPE_TOP) {

2582

++topMax;

2583

if (!draw_top || !inStepRange) {

continue;

}

lastTop = tIndex;

++topCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2590

if (recType == REC_TYPE_MARK) {

2591

++markMax;

2592

if (!draw_mark || !inStepRange) {

continue;

}

lastMark = tIndex;

++markCount;

bumpStep = true;

}

if (bumpStep) {

lastIndex = tIndex;

logStart = test[tIndex + 1];

2602

logRange = records.length / 2;

++curStep;

}

}

stepMax = (draw_add ? addMax : 0)

2607

+ (draw_active ? activeMax : 0)

reed

0dc4dd6

2015-03-24 13:55:33 -0700

[diff] [blame]

2608

+ (draw_angle ? angleMax : 0)

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

2609

+ (draw_coincidence ? coinMax : 0)

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2610

+ (draw_op ? opMax : 0)

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2611

+ (draw_sort ? sortMax : 0)

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

2612

+ (draw_top ? topMax : 0)

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2613

+ (draw_mark ? markMax : 0)

2614

+ (draw_intersection == 2 ? sectMax : draw_intersection == 3 ? sectMax2 : 0);

2615

if (stepMax == 0) {

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

2616

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]

2621

drawnConics = [];

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2622

drawnCubics = [];

2623

focusXmin = focusYmin = Infinity;

2624

focusXmax = focusYmax = -Infinity;

2625

var pathIndex = 0;

2626

var opLetter = 'S';

2627

for (var tIndex = lastIndex; tIndex >= 0; tIndex -= 3) {

2628

var recType = test[tIndex];

2629

var records = test[tIndex + 2];

2630

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

2631

var fragType = records[recordIndex];

2632

if (!typeof fragType == 'number' || fragType < 1 || fragType > FRAG_TYPE_LAST) {

2633

console.log("unknown in range frag type: " + fragType);

2634

throw "stop execution";

2635

}

2636

var frags = records[recordIndex + 1];

2637

focus_enabled = false;

2638

switch (recType) {

2639

case REC_TYPE_COMPUTED:

2640

if (draw_computed == 0) {

continue;

}

ctx.lineWidth = 1;

ctx.strokeStyle = pathIndex == 0 ? "black" : "red";

2645

ctx.fillStyle = "blue";

2646

var drawThis = false;

2647

switch (fragType) {

2648

case PATH_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2649

if ((draw_computed & 0x9) == 1 || ((draw_computed & 8) != 0

2650

&& (draw_computed & 7) == pathIndex)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2651

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]

2656

case PATH_CONIC:

2657

if ((draw_computed & 0xA) == 2 || ((draw_computed & 8) != 0

2658

&& (draw_computed & 7) == pathIndex)) {

2659

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

2660

frags[4], frags[5], frags[6]);

2661

drawThis = true;

2662

}

2663

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2664

case PATH_CUBIC:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2665

if ((draw_computed & 0xC) == 4 || ((draw_computed & 8) != 0

2666

&& (draw_computed & 7) == pathIndex)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2667

drawCubic(frags[0], frags[1], frags[2], frags[3],

2668

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);

2681

throw "stop execution";

2682

}

2683

if (!drawThis || collect_bounds) {

2684

break;

2685

}

2686

drawCurveSpecials(test, frags, fragType);

2687

break;

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

2688

case REC_TYPE_ALIGNED:

2689

if (draw_path < 4) {

2690

continue;

2691

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2692

case REC_TYPE_PATH:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2693

case REC_TYPE_PATH2:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

2694

if (REC_TYPE_ALIGNED != recType && draw_path >= 4) {

2695

continue;

2696

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

if (!draw_path) {

continue;

}

var firstPath = tIndex < secondPath;

2701

if ((draw_path & (firstPath ? 1 : 2)) == 0) {

continue;

}

ctx.lineWidth = 1;

ctx.strokeStyle = firstPath ? "black" : "red";

2706

ctx.fillStyle = "blue";

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2707

var frags2 = [];

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2708

switch (fragType) {

2709

case PATH_LINE:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2710

for (var i = 0; i < 4; ++ i) { frags2[i] = frags[i + 1]; }

2711

drawLine(frags2[0], frags2[1], frags2[2], frags2[3]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2712

break;

2713

case PATH_QUAD:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2714

for (var i = 0; i < 6; ++ i) { frags2[i] = frags[i + 1]; }

2715

drawQuad(frags2[0], frags2[1], frags2[2], frags2[3],

2716

frags2[4], frags2[5]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2717

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2718

case PATH_CONIC:

2719

for (var i = 0; i < 7; ++ i) { frags2[i] = frags[i + 1]; }

2720

drawConicWithQuads(frags2[0], frags2[1], frags2[2], frags2[3],

2721

frags2[4], frags2[5], frags2[6]);

2722

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2723

case PATH_CUBIC:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2724

for (var i = 0; i < 8; ++ i) { frags2[i] = frags[i + 1]; }

2725

drawCubic(frags2[0], frags2[1], frags2[2], frags2[3],

2726

frags2[4], frags2[5], frags2[6], frags2[7]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2727

break;

2728

default:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

2729

console.log("unknown " + recType + " frag type: " + fragType);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2730

throw "stop execution";

2731

}

2732

if (collect_bounds) {

2733

break;

2734

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2735

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;

2740

case OP_DIFFERENCE: opLetter = 'D'; break;

2741

case OP_UNION: opLetter = 'U'; break;

2742

case OP_XOR: opLetter = 'X'; break;

2743

default:

2744

console.log("unknown REC_TYPE_OP frag type: " + fragType);

2745

throw "stop execution";

2746

}

2747

break;

2748

case REC_TYPE_ACTIVE:

2749

if (!draw_active || (step_limit > 0 && tIndex < lastActive)) {

2750

continue;

2751

}

2752

var x1 = frags[SPAN_X1];

2753

var y1 = frags[SPAN_Y1];

2754

var x2 = frags[SPAN_X2];

2755

var y2 = frags[SPAN_Y2];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2756

var x3, y3, x3, y4, w;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2757

ctx.lineWidth = 3;

2758

ctx.strokeStyle = "rgba(0,0,255, 0.3)";

2759

focus_enabled = true;

2760

switch (fragType) {

2761

case ACTIVE_LINE_SPAN:

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2762

drawLine(x1, y1, x2, y2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2763

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2764

drawLineID(frags[0], x1, y1, x2, y2);

2765

}

2766

if (pt_labels) {

2767

var curve = [x1, y1, x2, y2];

2768

ctx.fillStyle = "blue";

2769

drawPoints(curve, PATH_LINE, pt_labels == 2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2770

}

2771

break;

2772

case ACTIVE_QUAD_SPAN:

2773

x3 = frags[SPAN_X3];

2774

y3 = frags[SPAN_Y3];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2775

drawQuad(x1, y1, x2, y2, x3, y3);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2776

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2777

drawQuadID(frags[0], x1, y1, x2, y2, x3, y3);

2778

}

2779

if (pt_labels) {

2780

var curve = [x1, y1, x2, y2, x3, y3];

2781

ctx.fillStyle = "blue";

2782

drawPoints(curve, PATH_QUAD, pt_labels == 2);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2783

}

2784

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2785

case ACTIVE_CONIC_SPAN:

2786

x3 = frags[SPAN_X3];

2787

y3 = frags[SPAN_Y3];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2788

w = frags[SPAN_K_W];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2789

drawConicWithQuads(x1, y1, x2, y2, x3, y3, w);

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2790

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2791

drawConicID(frags[0], x1, y1, x2, y2, x3, y3, w);

2792

}

2793

if (pt_labels) {

2794

var curve = [x1, y1, x2, y2, x3, y3, w];

2795

ctx.fillStyle = "blue";

2796

drawPoints(curve, PATH_CONIC, pt_labels == 2);

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2797

}

2798

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2799

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]

2804

drawCubic(x1, y1, x2, y2, x3, y3, x4, y4);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2805

if (draw_id) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

2806

drawCubicID(frags[0], x1, y1, x2, y2, x3, y3, x4, y4);

2807

}

2808

if (pt_labels) {

2809

var curve = [x1, y1, x2, y2, x3, y3, x4, y4];

2810

ctx.fillStyle = "blue";

2811

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);

2816

throw "stop execution";

2817

}

2818

break;

2819

case REC_TYPE_ACTIVE_OP:

2820

if (!draw_op || (step_limit > 0 && tIndex < lastOp)) {

2821

continue;

2822

}

2823

focus_enabled = true;

2824

ctx.lineWidth = 3;

2825

var activeSpan = frags[7] == "1";

2826

ctx.strokeStyle = activeSpan ? "rgba(45,160,0, 0.3)" : "rgba(255,45,0, 0.5)";

2827

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

2828

drawCurve(curve);

2829

if (draw_op > 1) {

2830

drawArc(curve, false, frags[3], frags[4]);

2831

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)"

2840

: closeCount == 1 ? "rgba(0,127,0, 0.3)"

2841

: closeCount == 2 ? "rgba(0,127,127, 0.3)"

2842

: closeCount == 3 ? "rgba(127,127,0, 0.3)"

2843

: "rgba(127,0,127, 0.3)";

2844

focus_enabled = true;

switch (fragType) {

case ADD_MOVETO:

break;

case ADD_LINETO:

if (step_limit == 0 || tIndex >= lastAdd) {

2850

drawLine(frags[0], frags[1], frags[2], frags[3]);

}

break;

case ADD_QUADTO:

if (step_limit == 0 || tIndex >= lastAdd) {

2855

drawQuad(frags[0], frags[1], frags[2], frags[3], frags[4], frags[5]);

2856

}

2857

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2858

case ADD_CONICTO:

2859

if (step_limit == 0 || tIndex >= lastAdd) {

2860

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

2861

frags[4], frags[5], frags[6]);

2862

}

2863

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2864

case ADD_CUBICTO:

2865

if (step_limit == 0 || tIndex >= lastAdd) {

2866

drawCubic(frags[0], frags[1], frags[2], frags[3],

2867

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);

2877

throw "stop execution";

2878

}

2879

break;

2880

case REC_TYPE_ANGLE:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2881

angleBetween = frags[18] == "T";

2882

afterIndex = 0;

2883

if (draw_angle == 0 || draw_angle == 3 || (step_limit > 0 && tIndex < lastAngle)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2884

continue;

2885

}

2886

focus_enabled = true;

2887

ctx.lineWidth = 3;

2888

ctx.strokeStyle = "rgba(127,45,127, 0.3)";

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2889

var leftCurve = curvePartialByID(test, frags[0], frags[4], frags[5]);

2890

var midCurve = curvePartialByID(test, frags[6], frags[10], frags[11]);

2891

var rightCurve = curvePartialByID(test, frags[12], frags[16], frags[17]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2892

drawCurve(leftCurve);

2893

drawCurve(rightCurve);

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2894

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]

2895

drawCurve(midCurve);

2896

if (draw_angle > 1) {

2897

drawOrder(leftCurve, 'L');

2898

drawOrder(rightCurve, 'R');

2899

}

2900

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2901

case REC_TYPE_AFTERPART:

2902

if (draw_angle != 3 || (step_limit > 0 && tIndex < lastAngle)) {

2903

continue;

2904

}

2905

ctx.strokeStyle = afterIndex == 0 ? "rgba(255,0,0, 1.0)"

2906

: (afterIndex == 1) == angleBetween ? "rgba(0,128,0, 1.0)"

2907

: "rgba(0,0,255, 1.0)";

2908

switch (fragType) {

2909

case PATH_LINE:

2910

drawLine(frags[0], frags[1], frags[2], frags[3]);

2911

break;

2912

case PATH_QUAD:

2913

drawQuad(frags[0], frags[1], frags[2], frags[3],

2914

frags[4], frags[5]);

2915

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2916

case PATH_CONIC:

2917

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

2918

frags[4], frags[5], frags[6]);

2919

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2920

case PATH_CUBIC:

2921

drawCubic(frags[0], frags[1], frags[2], frags[3],

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2922

frags[4], frags[5], frags[6], frags[7]);

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

2923

break;

2924

default:

2925

console.log("unknown REC_TYPE_AFTERPART frag type: " + fragType);

2926

throw "stop execution";

2927

}

2928

++afterIndex;

2929

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

2930

case REC_TYPE_COINCIDENCE:

2931

if (!draw_coincidence || (step_limit > 0 && tIndex < lastCoin)) {

2932

continue;

2933

}

2934

focus_enabled = true;

2935

ctx.lineWidth = 3;

2936

ctx.strokeStyle = "rgba(127,45,63, 0.3)";

2937

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

2938

drawCurve(curve);

2939

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

2940

case REC_TYPE_SECT:

2941

if (!draw_intersection) {

2942

continue;

2943

}

2944

if (draw_intersection != 1 && (step_limit > 0 && tIndex < lastSect)) {

2945

continue;

2946

}

2947

// draw_intersection == 1 : show all

2948

// draw_intersection == 2 : step == 0 ? show all : show intersection line #step

2949

// draw_intersection == 3 : step == 0 ? show all : show intersection #step

2950

ctx.lineWidth = 1;

2951

ctx.strokeStyle = "rgba(0,0,255, 0.3)";

2952

ctx.fillStyle = "blue";

2953

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;

2963

break;

2964

case INTERSECT_LINE_2:

2965

f.push(5, 6, 0, 10);

2966

f.push(8, 9, 7, 15);

2967

c1s = 1; c1l = 4; c2s = 11; c2l = 4;

2968

break;

2969

case INTERSECT_LINE_NO:

2970

c1s = 0; c1l = 4; c2s = 4; c2l = 4;

2971

break;

2972

case INTERSECT_QUAD_LINE:

2973

f.push(7, 8, 0, 9);

2974

c1s = 1; c1l = 6; c2s = 10; c2l = 4;

2975

break;

2976

case INTERSECT_QUAD_LINE_2:

2977

f.push(7, 8, 0, 12);

2978

f.push(10, 11, 9, 17);

2979

c1s = 1; c1l = 6; c2s = 13; c2l = 4;

2980

break;

2981

case INTERSECT_QUAD_LINE_NO:

2982

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;

2987

break;

2988

case INTERSECT_QUAD_2:

2989

f.push(7, 8, 0, 12);

2990

f.push(10, 11, 9, 19);

2991

c1s = 1; c1l = 6; c2s = 13; c2l = 6;

2992

break;

2993

case INTERSECT_QUAD_NO:

2994

c1s = 0; c1l = 6; c2s = 6; c2l = 6;

2995

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

2996

case INTERSECT_CONIC_LINE:

2997

f.push(8, 9, 0, 10);

2998

c1s = 1; c1l = 7; c2s = 11; c2l = 4;

2999

break;

3000

case INTERSECT_CONIC_LINE_2:

3001

f.push(8, 9, 0, 12);

3002

f.push(11, 12, 10, 18);

3003

c1s = 1; c1l = 7; c2s = 14; c2l = 4;

3004

break;

3005

case INTERSECT_CONIC_LINE_NO:

3006

c1s = 0; c1l = 7; c2s = 7; c2l = 4;

3007

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3008

case INTERSECT_CONIC_QUAD:

3009

f.push(8, 9, 0, 10);

3010

c1s = 1; c1l = 7; c2s = 11; c2l = 6;

3011

break;

3012

case INTERSECT_CONIC_QUAD_2:

3013

f.push(8, 9, 0, 12);

3014

f.push(11, 12, 10, 18);

3015

c1s = 1; c1l = 7; c2s = 14; c2l = 6;

3016

break;

3017

case INTERSECT_CONIC_QUAD_NO:

3018

c1s = 0; c1l = 7; c2s = 7; c2l = 6;

3019

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3020

case INTERSECT_CONIC:

3021

f.push(8, 9, 0, 10);

3022

c1s = 1; c1l = 7; c2s = 11; c2l = 7;

3023

break;

3024

case INTERSECT_CONIC_2:

3025

f.push(8, 9, 0, 13);

3026

f.push(11, 12, 10, 21);

3027

c1s = 1; c1l = 7; c2s = 14; c2l = 7;

3028

break;

3029

case INTERSECT_CONIC_NO:

3030

c1s = 0; c1l = 7; c2s = 7; c2l = 7;

3031

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3032

case INTERSECT_SELF_CUBIC:

3033

f.push(9, 10, 0, 11);

3034

c1s = 1; c1l = 8; c2s = 0; c2l = 0;

3035

break;

3036

case INTERSECT_SELF_CUBIC_NO:

3037

c1s = 0; c1l = 8; c2s = 0; c2l = 0;

3038

break;

3039

case INTERSECT_CUBIC_LINE:

3040

f.push(9, 10, 0, 11);

3041

c1s = 1; c1l = 8; c2s = 12; c2l = 4;

3042

break;

3043

case INTERSECT_CUBIC_LINE_2:

3044

f.push(9, 10, 0, 14);

3045

f.push(12, 13, 11, 19);

3046

c1s = 1; c1l = 8; c2s = 15; c2l = 4;

3047

break;

3048

case INTERSECT_CUBIC_LINE_3:

3049

f.push(9, 10, 0, 17);

3050

f.push(12, 13, 11, 22);

3051

f.push(15, 16, 14, 23);

3052

c1s = 1; c1l = 8; c2s = 18; c2l = 4;

3053

break;

3054

case INTERSECT_CUBIC_QUAD_NO:

3055

c1s = 0; c1l = 8; c2s = 8; c2l = 6;

3056

break;

3057

case INTERSECT_CUBIC_QUAD:

3058

f.push(9, 10, 0, 11);

3059

c1s = 1; c1l = 8; c2s = 12; c2l = 6;

3060

break;

3061

case INTERSECT_CUBIC_QUAD_2:

3062

f.push(9, 10, 0, 14);

3063

f.push(12, 13, 11, 21);

3064

c1s = 1; c1l = 8; c2s = 15; c2l = 6;

3065

break;

3066

case INTERSECT_CUBIC_QUAD_3:

3067

f.push(9, 10, 0, 17);

3068

f.push(12, 13, 11, 24);

3069

f.push(15, 16, 14, 25);

3070

c1s = 1; c1l = 8; c2s = 18; c2l = 6;

3071

break;

3072

case INTERSECT_CUBIC_QUAD_4:

3073

f.push(9, 10, 0, 20);

3074

f.push(12, 13, 11, 27);

3075

f.push(15, 16, 14, 28);

3076

f.push(18, 19, 17, 29);

3077

c1s = 1; c1l = 8; c2s = 21; c2l = 6;

3078

break;

3079

case INTERSECT_CUBIC_LINE_NO:

3080

c1s = 0; c1l = 8; c2s = 8; c2l = 4;

3081

break;

3082

case INTERSECT_CUBIC:

3083

f.push(9, 10, 0, 11);

3084

c1s = 1; c1l = 8; c2s = 12; c2l = 8;

3085

break;

3086

case INTERSECT_CUBIC_2:

3087

f.push(9, 10, 0, 14);

3088

f.push(12, 13, 11, 23);

3089

c1s = 1; c1l = 8; c2s = 15; c2l = 8;

3090

break;

3091

case INTERSECT_CUBIC_3:

3092

f.push(9, 10, 0, 17);

3093

f.push(12, 13, 11, 26);

3094

f.push(15, 16, 14, 27);

3095

c1s = 1; c1l = 8; c2s = 18; c2l = 8;

3096

break;

3097

case INTERSECT_CUBIC_4:

3098

f.push(9, 10, 0, 20);

3099

f.push(12, 13, 11, 29);

3100

f.push(15, 16, 14, 30);

3101

f.push(18, 19, 17, 31);

3102

c1s = 1; c1l = 8; c2s = 21; c2l = 8;

3103

break;

3104

case INTERSECT_CUBIC_NO:

3105

c1s = 0; c1l = 8; c2s = 8; c2l = 8;

3106

break;

3107

default:

3108

console.log("unknown REC_TYPE_SECT frag type: " + fragType);

3109

throw "stop execution";

3110

}

3111

if (draw_intersection != 1) {

3112

var id = -1;

3113

var curve;

3114

switch (c1l) {

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3115

case 4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3116

drawLine(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3]);

3117

if (draw_id) {

3118

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3]];

3119

id = idByCurve(test, curve, PATH_LINE);

}

break;

case 6:

drawQuad(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3124

frags[c1s + 4], frags[c1s + 5]);

3125

if (draw_id) {

3126

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3127

frags[c1s + 4], frags[c1s + 5]];

3128

id = idByCurve(test, curve, PATH_QUAD);

3129

}

3130

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3131

case 7:

3132

drawConicWithQuads(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3133

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6]);

3134

if (draw_id) {

3135

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3136

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6]];

3137

id = idByCurve(test, curve, PATH_CONIC);

3138

}

3139

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3140

case 8:

3141

drawCubic(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3142

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6], frags[c1s + 7]);

3143

if (draw_id) {

3144

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3145

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6], frags[c1s + 7]];

3146

id = idByCurve(test, curve, PATH_CUBIC);

}

break;

}

if (id >= 0) {

drawID(curve, id);

}

id = -1;

switch (c2l) {

case 0:

break;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3157

case 4:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3158

drawLine(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3]);

3159

if (draw_id) {

3160

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3]];

3161

id = idByCurve(test, curve, PATH_LINE);

}

break;

case 6:

drawQuad(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3166

frags[c2s + 4], frags[c2s + 5]);

3167

if (draw_id) {

3168

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3169

frags[c2s + 4], frags[c2s + 5]];

3170

id = idByCurve(test, curve, PATH_QUAD);

3171

}

3172

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3173

case 7:

3174

drawConicWithQuads(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3175

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6]);

3176

if (draw_id) {

3177

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3178

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6]];

3179

id = idByCurve(test, curve, PATH_CONIC);

3180

}

3181

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3182

case 8:

3183

drawCubic(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3184

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6], frags[c2s + 7]);

3185

if (draw_id) {

3186

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3187

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6], frags[c2s + 7]];

3188

id = idByCurve(test, curve, PATH_CUBIC);

}

break;

}

if (id >= 0) {

drawID(curve, id);

}

}

if (collect_bounds) {

3197

break;

3198

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3199

if (draw_intersection != 3 || step_limit == 0 || tIndex >= lastSect) {

3200

for (var idx = 0; idx < f.length; idx += 4) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3201

drawPoint(frags[f[idx]], frags[f[idx + 1]], true);

3202

}

3203

}

3204

if (!draw_intersectT) {

3205

break;

3206

}

3207

ctx.fillStyle = "red";

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3208

if (draw_intersection != 3 || step_limit == 0 || tIndex >= lastSect) {

3209

for (var idx = 0; idx < f.length; idx += 4) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3210

drawTAtPointUp(frags[f[idx]], frags[f[idx + 1]], frags[f[idx + 2]]);

3211

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)";

3221

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);

3230

throw "stop execution";

3231

}

3232

break;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3233

case REC_TYPE_TOP:

3234

if (!draw_top || (step_limit > 0 && tIndex < lastTop)) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = "rgba(127,127,0, 0.5)";

3239

focus_enabled = true;

3240

{

3241

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

3242

drawCurve(curve);

3243

var type = PATH_LINE + (curve.length / 2 - 2);

3244

var mid = pointAtT(curve, type, 0.5);

3245

var d = dxy_at_t(curve, type, 0.5);

3246

drawArrow(mid.x, mid.y, d.x, d.y, 0.3);

3247

}

3248

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3249

case REC_TYPE_MARK:

3250

if (!draw_mark || (step_limit > 0 && tIndex < lastMark)) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = fragType >= MARK_DONE_LINE ?

3255

"rgba(127,0,127, 0.5)" : "rgba(127,127,0, 0.5)";

3256

focus_enabled = true;

switch (fragType) {

case MARK_LINE:

case MARK_DONE_LINE:

case MARK_UNSORTABLE_LINE:

3261

case MARK_SIMPLE_LINE:

3262

case MARK_SIMPLE_DONE_LINE:

3263

case MARK_DONE_UNARY_LINE:

3264

drawLinePartial(frags[1], frags[2], frags[3], frags[4],

3265

frags[5], frags[9]);

3266

if (draw_id) {

3267

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:

3274

case MARK_SIMPLE_QUAD:

3275

case MARK_SIMPLE_DONE_QUAD:

3276

case MARK_DONE_UNARY_QUAD:

3277

drawQuadPartial(frags[1], frags[2], frags[3], frags[4],

3278

frags[5], frags[6], frags[7], frags[11]);

3279

if (draw_id) {

3280

drawQuadPartialID(frags[0], frags[1], frags[2], frags[3], frags[4],

3281

frags[5], frags[6], frags[7], frags[11]);

}

break;

case MARK_CUBIC:

case MARK_DONE_CUBIC:

3286

case MARK_UNSORTABLE_CUBIC:

3287

case MARK_SIMPLE_CUBIC:

3288

case MARK_SIMPLE_DONE_CUBIC:

3289

case MARK_DONE_UNARY_CUBIC:

3290

drawCubicPartial(frags[1], frags[2], frags[3], frags[4],

3291

frags[5], frags[6], frags[7], frags[8], frags[9], frags[13]);

3292

if (draw_id) {

3293

drawCubicPartialID(frags[0], frags[1], frags[2], frags[3], frags[4],

3294

frags[5], frags[6], frags[7], frags[8], frags[9], frags[13]);

3295

}

3296

break;

3297

case MARK_ANGLE_LAST:

3298

// FIXME: ignored for now

3299

break;

3300

default:

3301

console.log("unknown REC_TYPE_MARK frag type: " + fragType);

3302

throw "stop execution";

}

break;

default:

continue;

}

}

switch (recType) {

case REC_TYPE_SORT:

if (!draw_sort || (step_limit > 0 && tIndex < lastSort)) {

3312

break;

3313

}

3314

var angles = []; // use tangent lines to describe arcs

var windFrom = [];

var windTo = [];

var opp = [];

var minXY = Number.MAX_VALUE;

3319

var partial;

3320

focus_enabled = true;

3321

var someUnsortable = false;

3322

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

3323

var fragType = records[recordIndex];

3324

var frags = records[recordIndex + 1];

3325

var unsortable = (fragType == SORT_UNARY && frags[14]) ||

3326

(fragType == SORT_BINARY && frags[16]);

3327

someUnsortable |= unsortable;

switch (fragType) {

case SORT_UNARY:

case SORT_BINARY:

partial = curvePartialByID(test, frags[0], frags[6], frags[8]);

3332

break;

3333

default:

3334

console.log("unknown REC_TYPE_SORT frag type: " + fragType);

3335

throw "stop execution";

3336

}

3337

var dx = boundsWidth(partial);

3338

var dy = boundsHeight(partial);

3339

minXY = Math.min(minXY, dx * dx + dy * dy);

3340

if (collect_bounds) {

3341

continue;

3342

}

3343

angles.push(tangent(partial));

3344

var from = frags[12];

var to = frags[12];

var sgn = frags[10];

if (sgn < 0) {

from -= frags[11];

} else if (sgn > 0) {

3350

to -= frags[11];

3351

}

3352

windFrom.push(from + (unsortable ? "!" : ""));

3353

windTo.push(to + (unsortable ? "!" : ""));

3354

opp.push(fragType == SORT_BINARY);

3355

if (draw_sort == 1) {

3356

drawOrder(partial, frags[12]);

3357

} else {

3358

drawOrder(partial, (recordIndex / 2) + 1);

3359

}

3360

}

3361

var radius = Math.sqrt(minXY) / 2 * scale;

3362

radius = Math.min(50, radius);

3363

var scaledRadius = radius / scale;

3364

var centerX = partial[0];

3365

var centerY = partial[1];

3366

if (collect_bounds) {

3367

if (focus_enabled) {

3368

focusXmin = Math.min(focusXmin, centerX - scaledRadius);

3369

focusYmin = Math.min(focusYmin, centerY - scaledRadius);

3370

focusXmax = Math.max(focusXmax, centerX + scaledRadius);

3371

focusYmax = Math.max(focusYmax, centerY + scaledRadius);

}

break;

}

break;

default:

break;

}

}

if (collect_bounds) {

3381

return;

3382

}

3383

if (draw_log && logStart >= 0) {

3384

ctx.font = "normal 10px Arial";

3385

ctx.textAlign = "left";

3386

ctx.beginPath();

3387

var top = screenHeight - 20 - (logRange + 2) * 10;

3388

ctx.rect(50, top, screenWidth - 100, (logRange + 2) * 10);

3389

ctx.fillStyle = "white";

3390

ctx.fill();

3391

ctx.fillStyle = "rgba(0,0,0, 0.5)";

3392

if (logStart > 0) {

3393

ctx.fillText(lines[logStart - 1], 50, top + 8);

3394

}

3395

ctx.fillStyle = "black";

3396

for (var idx = 0; idx < logRange; ++idx) {

3397

ctx.fillText(lines[logStart + idx], 50, top + 18 + 10 * idx);

3398

}

3399

ctx.fillStyle = "rgba(0,0,0, 0.5)";

3400

if (logStart + logRange < lines.length) {

3401

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]

3406

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3407

// drawBox(pos++, "yellow", "black", opLetter, true, '');

3408

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_intersection > 1 ? sectCount : sectMax2, draw_intersection, intersectionKey);

3409

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_add ? addCount : addMax, draw_add, addKey);

3410

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_active ? activeCount : activeMax, draw_active, activeKey);

3411

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]

3412

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]

3413

drawBox(pos++, "rgba(127,127,0, 0.3)", "black", draw_op ? opCount : opMax, draw_op, opKey);

3414

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]

3415

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]

3416

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]

3417

drawBox(pos++, "black", "white",

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3418

(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]

3419

drawBox(pos++, "rgba(0,63,0, 0.7)", "white",

3420

(new Array('Q', 'Q', 'C', 'QC', 'Qc', 'Cq'))[draw_computed],

3421

draw_computed != 0, computedKey);

3422

drawBox(pos++, "green", "black", step_limit, drawSomething, '');

3423

drawBox(pos++, "green", "black", stepMax, drawSomething, '');

3424

drawBox(pos++, "rgba(255,0,0, 0.6)", "black", lastIndex, drawSomething & draw_log, '');

3425

drawBox(pos++, "rgba(255,0,0, 0.6)", "black", test.length - 1, drawSomething & draw_log, '');

if (curve_t) {

drawCurveTControl();

}

ctx.font = "normal 20px Arial";

3430

ctx.fillStyle = "rgba(0,0,0, 0.3)";

3431

ctx.textAlign = "right";

3432

ctx.fillText(scale.toFixed(decimal_places) + 'x' , screenWidth - 10, screenHeight - 5);

3433

}

3434

if (draw_hints) {

3435

ctx.font = "normal 10px Arial";

3436

ctx.fillStyle = "rgba(0,0,0, 0.5)";

3437

ctx.textAlign = "right";

3438

var y = 4;

3439

ctx.fillText("control lines : " + controlLinesKey, ctx.screenWidthwidth - 10, pos * 50 + y++ * 10);

3440

ctx.fillText("curve t : " + curveTKey, screenWidth - 10, pos * 50 + y++ * 10);

3441

ctx.fillText("deriviatives : " + deriviativesKey, screenWidth - 10, pos * 50 + y++ * 10);

3442

ctx.fillText("intersect t : " + intersectTKey, screenWidth - 10, pos * 50 + y++ * 10);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3443

ctx.fillText("log : " + logKey, screenWidth - 10, pos * 50 + y++ * 10);

3444

ctx.fillText("log curve : " + logCurvesKey, screenWidth - 10, pos * 50 + y++ * 10);

3445

ctx.fillText("mid point : " + midpointKey, screenWidth - 10, pos * 50 + y++ * 10);

3446

ctx.fillText("points : " + ptsKey, screenWidth - 10, pos * 50 + y++ * 10);

3447

ctx.fillText("sequence : " + sequenceKey, screenWidth - 10, pos * 50 + y++ * 10);

3448

ctx.fillText("xy : " + xyKey, screenWidth - 10, pos * 50 + y++ * 10);

}

}

function drawBox(y, backC, foreC, str, enable, label) {

3453

ctx.beginPath();

3454

ctx.fillStyle = backC;

3455

ctx.rect(screenWidth - 40, y * 50 + 10, 40, 30);

3456

ctx.fill();

3457

ctx.font = "normal 16px Arial";

3458

ctx.fillStyle = foreC;

3459

ctx.textAlign = "center";

3460

ctx.fillText(str, screenWidth - 20, y * 50 + 32);

3461

if (!enable) {

3462

ctx.fillStyle = "rgba(255,255,255, 0.5)";

ctx.fill();

}

if (label != '') {

ctx.font = "normal 9px Arial";

3467

ctx.fillStyle = "black";

3468

ctx.fillText(label, screenWidth - 47, y * 50 + 40);

}

}

function drawCurveTControl() {

3473

ctx.lineWidth = 2;

3474

ctx.strokeStyle = "rgba(0,0,0, 0.3)";

3475

ctx.beginPath();

3476

ctx.rect(screenWidth - 80, 40, 28, screenHeight - 80);

3477

ctx.stroke();

3478

var ty = 40 + curveT * (screenHeight - 80);

3479

ctx.beginPath();

3480

ctx.moveTo(screenWidth - 80, ty);

3481

ctx.lineTo(screenWidth - 85, ty - 5);

3482

ctx.lineTo(screenWidth - 85, ty + 5);

3483

ctx.lineTo(screenWidth - 80, ty);

3484

ctx.fillStyle = "rgba(0,0,0, 0.6)";

3485

ctx.fill();

3486

var num = curveT.toFixed(decimal_places);

3487

ctx.font = "normal 10px Arial";

3488

ctx.textAlign = "left";

3489

ctx.fillText(num, screenWidth - 78, ty);

3490

}

3491

3492

function ptInTControl() {

3493

var e = window.event;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3494

var tgt = e.target || e.srcElement;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3495

var left = tgt.offsetLeft;

3496

var top = tgt.offsetTop;

3497

var x = (e.clientX - left);

3498

var y = (e.clientY - top);

3499

if (x < screenWidth - 80 || x > screenWidth - 50) {

3500

return false;

3501

}

3502

if (y < 40 || y > screenHeight - 80) {

3503

return false;

3504

}

3505

curveT = (y - 40) / (screenHeight - 120);

3506

if (curveT < 0 || curveT > 1) {

3507

throw "stop execution";

}

return true;

}

function drawTop() {

if (tests[testIndex] == null) {

3514

var str = testDivs[testIndex].textContent;

3515

parse_all(str);

3516

var title = testDivs[testIndex].id.toString();

3517

testTitles[testIndex] = title;

3518

}

3519

init(tests[testIndex]);

redraw();

}

function redraw() {

if (focus_on_selection) {

3525

collect_bounds = true;

3526

draw(tests[testIndex], testLines[testIndex], testTitles[testIndex]);

3527

collect_bounds = false;

3528

if (focusXmin < focusXmax && focusYmin < focusYmax) {

3529

setScale(focusXmin, focusXmax, focusYmin, focusYmax);

}

}

ctx.beginPath();

ctx.fillStyle = "white";

3534

ctx.rect(0, 0, screenWidth, screenHeight);

3535

ctx.fill();

3536

draw(tests[testIndex], testLines[testIndex], testTitles[testIndex]);

3537

}

3538

3539

function dumpCurvePartial(test, id, t0, t1) {

3540

var curve = curveByID(test, id);

3541

var name = ["line", "quad", "cubic"][curve.length / 2 - 2];

3542

console.log("id=" + id + " " + name + "=" + curveToString(curve)

3543

+ " t0=" + t0 + " t1=" + t1

3544

+ " partial=" + curveToString(curvePartialByID(test, id, t0, t1)));

3545

}

3546

3547

function dumpAngleTest(test, id, t0, t1) {

3548

var curve = curveByID(test, id);

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3549

console.log(" { {" + curveToString(curve) + "}, "

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3550

+ curve.length / 2 + ", " + t0 + ", " + t1 + ", {} }, //");

3551

}

3552

3553

function dumpLogToConsole() {

if (logStart < 0) {

return;

}

var test = tests[testIndex];

3558

var recType = REC_TYPE_UNKNOWN;

3559

var records;

3560

for (var index = 0; index < test.length; index += 3) {

3561

var lastLineNo = test[index + 1];

3562

if (lastLineNo >= logStart && lastLineNo < logStart + logRange) {

3563

recType = test[index];

3564

records = test[index + 2];

break;

}

}

if (recType == REC_TYPE_UNKNOWN) {

3569

return;

3570

}

3571

var lines = testLines[testIndex];

3572

for (var idx = 0; idx < logRange; ++idx) {

3573

var line = lines[logStart + idx];

3574

console.log(line);

3575

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

3576

var fragType = records[recordIndex];

3577

var frags = records[recordIndex + 1];

3578

if (recType == REC_TYPE_ANGLE && fragType == ANGLE_AFTER) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3579

dumpCurvePartial(test, frags[0], frags[4], frags[5]);

3580

dumpCurvePartial(test, frags[6], frags[10], frags[11]);

3581

dumpCurvePartial(test, frags[12], frags[16], frags[17]);

3582

console.log("\nstatic IntersectData intersectDataSet[] = { //");

3583

dumpAngleTest(test, frags[0], frags[4], frags[5]);

3584

dumpAngleTest(test, frags[6], frags[10], frags[11]);

3585

dumpAngleTest(test, frags[12], frags[16], frags[17]);

3586

console.log("}; //");

}

}

}

}

var activeKey = 'a';

var pathKey = 'b';

var pathBackKey = 'B';

3595

var centerKey = 'c';

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3596

var coincidenceKey = 'C';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3597

var addKey = 'd';

3598

var deriviativesKey = 'f';

3599

var angleKey = 'g';

3600

var angleBackKey = 'G';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3601

var intersectionKey = 'i';

3602

var intersectionBackKey = 'I';

3603

var sequenceKey = 'j';

3604

var midpointKey = 'k';

3605

var logKey = 'l';

3606

var logToConsoleKey = 'L';

var markKey = 'm';

var sortKey = 'o';

var opKey = 'p';

var opBackKey = 'P';

var computedKey = 'q';

3612

var computedBackKey = 'Q';

3613

var stepKey = 's';

3614

var stepBackKey = 'S';

3615

var intersectTKey = 't';

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3616

var topKey = 'T';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3617

var curveTKey = 'u';

3618

var controlLinesBackKey = 'V';

3619

var controlLinesKey = 'v';

3620

var ptsKey = 'x';

3621

var xyKey = 'y';

3622

var logCurvesKey = 'z';

3623

var focusKey = '`';

3624

var idKey = '.';

3625

var retinaKey = '\\';

3626

3627

function doKeyPress(evt) {

3628

var char = String.fromCharCode(evt.charCode);

3629

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]

3646

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3647

break;

3648

case addKey:

3649

draw_add ^= true;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3650

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3651

break;

3652

case angleKey:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3653

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]

3662

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3663

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3664

case coincidenceKey:

3665

draw_coincidence ^= true;

3666

redraw();

3667

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3668

case controlLinesBackKey:

3669

control_lines = (control_lines + 3) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3670

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3671

break;

3672

case controlLinesKey:

3673

control_lines = (control_lines + 1) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3674

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3675

break;

3676

case computedBackKey:

3677

draw_computed = (draw_computed + 5) % 6;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3678

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3679

break;

3680

case computedKey:

3681

draw_computed = (draw_computed + 1) % 6;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3682

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:

3692

draw_deriviatives = (draw_deriviatives + 1) % 3;

redraw();

break;

case focusKey:

focus_on_selection ^= true;

3697

setScale(xmin, xmax, ymin, ymax);

3698

redraw();

3699

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

case idKey:

draw_id ^= true;

redraw();

break;

case intersectionBackKey:

3705

draw_intersection = (draw_intersection + 3) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3706

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3707

break;

3708

case intersectionKey:

3709

draw_intersection = (draw_intersection + 1) % 4;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3710

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3711

break;

3712

case intersectTKey:

3713

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;

3742

redraw();

3743

break;

3744

case pathKey:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3745

draw_path = (draw_path + 1) % (4 + (hasAlignedPath ? 3 : 0));

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3746

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3747

break;

3748

case pathBackKey:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3749

draw_path = (draw_path + 3 + (hasAlignedPath ? 3 : 0)) % (4 + (hasAlignedPath ? 3 : 0));

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3750

redraw();

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3751

break;

3752

case ptsKey:

3753

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) {

3771

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]

3786

case xyKey:

3787

debug_xy = (debug_xy + 1) % 3;

redraw();

break;

case '-':

focusWasOn = focus_on_selection;

3792

if (focusWasOn) {

3793

focus_on_selection = false;

scale /= 1.2;

} else {

scale /= 2;

calcLeftTop();

}

redraw();

focus_on_selection = focusWasOn;

break;

case '=':

case '+':

focusWasOn = focus_on_selection;

3805

if (focusWasOn) {

3806

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) {

3830

var char = evt.keyCode;

3831

var preventDefault = false;

3832

switch (char) {

3833

case 37: // left arrow

if (evt.shiftKey) {

testIndex -= 9;

}

if (--testIndex < 0)

testIndex = tests.length - 1;

3839

drawTop();

3840

preventDefault = true;

3841

break;

3842

case 39: // right arrow

if (evt.shiftKey) {

testIndex += 9;

}

if (++testIndex >= tests.length)

3847

testIndex = 0;

3848

drawTop();

3849

preventDefault = true;

3850

break;

3851

}

3852

if (preventDefault) {

3853

evt.preventDefault();

return false;

}

return true;

}

(function() {

var hidden = "hidden";

3861

3862

// Standards:

3863

if (hidden in document)

3864

document.addEventListener("visibilitychange", onchange);

3865

else if ((hidden = "mozHidden") in document)

3866

document.addEventListener("mozvisibilitychange", onchange);

3867

else if ((hidden = "webkitHidden") in document)

3868

document.addEventListener("webkitvisibilitychange", onchange);

3869

else if ((hidden = "msHidden") in document)

3870

document.addEventListener("msvisibilitychange", onchange);

3871

// IE 9 and lower:

3872

else if ('onfocusin' in document)

3873

document.onfocusin = document.onfocusout = onchange;

3874

// All others:

3875

else

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3876

window.onpageshow = window.onpagehide

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3877

= window.onfocus = window.onblur = onchange;

3878

3879

function onchange (evt) {

3880

var v = 'visible', h = 'hidden',

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3881

evtMap = {

3882

focus:v, focusin:v, pageshow:v, blur:h, focusout:h, pagehide:h

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3883

};

3884

3885

evt = evt || window.event;

3886

if (evt.type in evtMap)

3887

document.body.className = evtMap[evt.type];

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3888

else

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3889

document.body.className = this[hidden] ? "hidden" : "visible";

}

})();

function calcXY() {

var e = window.event;

caryclark

2016-07-18 10:01:36 -0700

[diff] [blame]

3895

var tgt = e.target || e.srcElement;

caryclark