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

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

[diff] [blame]

876

</div>

caryclark

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

[diff] [blame]

877

caryclark

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

[diff] [blame]

</div>

var testDivs = [

caryclark

2bec26a

2016-05-26 09:01:47 -0700

[diff] [blame^]

883

fuzz763_4713_b,

884

fuzz763_4713parts,

caryclark

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

[diff] [blame]

885

];

886

887

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;

896

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]

901

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;

906

var control_lines = 0;

907

var curve_t = false;

908

var debug_xy = 1;

909

var focus_enabled = false;

910

var focus_on_selection = false;

911

var step_limit = 0;

912

var draw_active = false;

913

var draw_add = false;

914

var draw_angle = 0;

caryclark

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

[diff] [blame]

915

var draw_coincidence = false;

caryclark

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

[diff] [blame]

916

var draw_deriviatives = 0;

917

var draw_hints = false;

caryclark

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

[diff] [blame]

918

var draw_id = false;

919

var draw_intersection = 0;

920

var draw_intersectT = false;

921

var draw_legend = true;

922

var draw_log = false;

923

var draw_mark = false;

924

var draw_midpoint = false;

925

var draw_op = 0;

926

var draw_sequence = false;

927

var draw_sort = 0;

caryclark

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

[diff] [blame]

928

var draw_top = false;

caryclark

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

[diff] [blame]

929

var draw_path = 3;

930

var draw_computed = 0;

931

var retina_scale = !!window.devicePixelRatio;

var activeCount = 0;

var addCount = 0;

var angleCount = 0;

caryclark

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

[diff] [blame]

936

var coinCount = 0;

caryclark

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

[diff] [blame]

937

var opCount = 0;

938

var sectCount = 0;

939

var sortCount = 0;

caryclark

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

[diff] [blame]

940

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]

945

var coinMax = 0;

caryclark

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

[diff] [blame]

946

var sectMax = 0;

947

var sectMax2 = 0;

948

var sortMax = 0;

caryclark

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

[diff] [blame]

949

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]

955

var hasAlignedPath = false;

caryclark

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

[diff] [blame]

956

var hasComputedPath = false;

caryclark

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

[diff] [blame]

957

var angleBetween = false;

958

var afterIndex = 0;

caryclark

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

[diff] [blame]

959

960

var firstActiveSpan = -1;

var logStart = -1;

var logRange = 0;

var SPAN_ID = 0;

var SPAN_X1 = SPAN_ID + 1;

966

var SPAN_Y1 = SPAN_X1 + 1;

967

var SPAN_X2 = SPAN_Y1 + 1;

968

var SPAN_Y2 = SPAN_X2 + 1;

caryclark

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

[diff] [blame]

969

caryclark

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

[diff] [blame]

970

var SPAN_L_T = SPAN_Y2 + 1;

971

var SPAN_L_TX = SPAN_L_T + 1;

972

var SPAN_L_TY = SPAN_L_TX + 1;

973

var SPAN_L_TEND = SPAN_L_TY + 1;

974

var SPAN_L_OTHER = SPAN_L_TEND + 1;

975

var SPAN_L_OTHERT = SPAN_L_OTHER + 1;

976

var SPAN_L_OTHERI = SPAN_L_OTHERT + 1;

977

var SPAN_L_SUM = SPAN_L_OTHERI + 1;

978

var SPAN_L_VAL = SPAN_L_SUM + 1;

979

var SPAN_L_OPP = SPAN_L_VAL + 1;

980

981

var SPAN_X3 = SPAN_Y2 + 1;

982

var SPAN_Y3 = SPAN_X3 + 1;

caryclark

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

[diff] [blame]

983

caryclark

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

[diff] [blame]

984

var SPAN_Q_T = SPAN_Y3 + 1;

985

var SPAN_Q_TX = SPAN_Q_T + 1;

986

var SPAN_Q_TY = SPAN_Q_TX + 1;

987

var SPAN_Q_TEND = SPAN_Q_TY + 1;

988

var SPAN_Q_OTHER = SPAN_Q_TEND + 1;

989

var SPAN_Q_OTHERT = SPAN_Q_OTHER + 1;

990

var SPAN_Q_OTHERI = SPAN_Q_OTHERT + 1;

991

var SPAN_Q_SUM = SPAN_Q_OTHERI + 1;

992

var SPAN_Q_VAL = SPAN_Q_SUM + 1;

993

var SPAN_Q_OPP = SPAN_Q_VAL + 1;

994

caryclark

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

[diff] [blame]

995

var SPAN_K_W = SPAN_Y3 + 1;

996

var SPAN_K_T = SPAN_K_W + 1;

997

var SPAN_K_TX = SPAN_K_T + 1;

998

var SPAN_K_TY = SPAN_K_TX + 1;

999

var SPAN_K_TEND = SPAN_K_TY + 1;

1000

var SPAN_K_OTHER = SPAN_K_TEND + 1;

1001

var SPAN_K_OTHERT = SPAN_K_OTHER + 1;

1002

var SPAN_K_OTHERI = SPAN_K_OTHERT + 1;

1003

var SPAN_K_SUM = SPAN_K_OTHERI + 1;

1004

var SPAN_K_VAL = SPAN_K_SUM + 1;

1005

var SPAN_K_OPP = SPAN_K_VAL + 1;

1006

caryclark

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

[diff] [blame]

1007

var SPAN_X4 = SPAN_Y3 + 1;

1008

var SPAN_Y4 = SPAN_X4 + 1;

caryclark

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

[diff] [blame]

1009

caryclark

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

[diff] [blame]

1010

var SPAN_C_T = SPAN_Y4 + 1;

1011

var SPAN_C_TX = SPAN_C_T + 1;

1012

var SPAN_C_TY = SPAN_C_TX + 1;

1013

var SPAN_C_TEND = SPAN_C_TY + 1;

1014

var SPAN_C_OTHER = SPAN_C_TEND + 1;

1015

var SPAN_C_OTHERT = SPAN_C_OTHER + 1;

1016

var SPAN_C_OTHERI = SPAN_C_OTHERT + 1;

1017

var SPAN_C_SUM = SPAN_C_OTHERI + 1;

1018

var SPAN_C_VAL = SPAN_C_SUM + 1;

1019

var SPAN_C_OPP = SPAN_C_VAL + 1;

1020

1021

var ACTIVE_LINE_SPAN = 1;

1022

var ACTIVE_QUAD_SPAN = ACTIVE_LINE_SPAN + 1;

caryclark

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

[diff] [blame]

1023

var ACTIVE_CONIC_SPAN = ACTIVE_QUAD_SPAN + 1;

1024

var ACTIVE_CUBIC_SPAN = ACTIVE_CONIC_SPAN + 1;

caryclark

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

[diff] [blame]

1025

1026

var ADD_MOVETO = ACTIVE_CUBIC_SPAN + 1;

1027

var ADD_LINETO = ADD_MOVETO + 1;

1028

var ADD_QUADTO = ADD_LINETO + 1;

caryclark

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

[diff] [blame]

1029

var ADD_CONICTO = ADD_QUADTO + 1;

1030

var ADD_CUBICTO = ADD_CONICTO + 1;

caryclark

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

[diff] [blame]

1031

var ADD_CLOSE = ADD_CUBICTO + 1;

1032

var ADD_FILL = ADD_CLOSE + 1;

1033

1034

var PATH_LINE = ADD_FILL + 1;

1035

var PATH_QUAD = PATH_LINE + 1;

caryclark

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

[diff] [blame]

1036

var PATH_CONIC = PATH_QUAD + 1;

1037

var PATH_CUBIC = PATH_CONIC + 1;

caryclark

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

[diff] [blame]

1038

1039

var INTERSECT_LINE = PATH_CUBIC + 1;

1040

var INTERSECT_LINE_2 = INTERSECT_LINE + 1;

1041

var INTERSECT_LINE_NO = INTERSECT_LINE_2 + 1;

1042

var INTERSECT_QUAD_LINE = INTERSECT_LINE_NO + 1;

1043

var INTERSECT_QUAD_LINE_2 = INTERSECT_QUAD_LINE + 1;

1044

var INTERSECT_QUAD_LINE_NO = INTERSECT_QUAD_LINE_2 + 1;

1045

var INTERSECT_QUAD = INTERSECT_QUAD_LINE_NO + 1;

1046

var INTERSECT_QUAD_2 = INTERSECT_QUAD + 1;

1047

var INTERSECT_QUAD_NO = INTERSECT_QUAD_2 + 1;

caryclark

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

[diff] [blame]

1048

var INTERSECT_CONIC_LINE = INTERSECT_QUAD_NO + 1;

1049

var INTERSECT_CONIC_LINE_2 = INTERSECT_CONIC_LINE + 1;

1050

var INTERSECT_CONIC_LINE_NO = INTERSECT_CONIC_LINE_2 + 1;

1051

var INTERSECT_CONIC = INTERSECT_CONIC_LINE_NO + 1;

1052

var INTERSECT_CONIC_2 = INTERSECT_CONIC + 1;

1053

var INTERSECT_CONIC_NO = INTERSECT_CONIC_2 + 1;

1054

var INTERSECT_SELF_CUBIC = INTERSECT_CONIC_NO + 1;

caryclark

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

[diff] [blame]

1055

var INTERSECT_SELF_CUBIC_NO = INTERSECT_SELF_CUBIC + 1;

1056

var INTERSECT_CUBIC_LINE = INTERSECT_SELF_CUBIC_NO + 1;

1057

var INTERSECT_CUBIC_LINE_2 = INTERSECT_CUBIC_LINE + 1;

1058

var INTERSECT_CUBIC_LINE_3 = INTERSECT_CUBIC_LINE_2 + 1;

1059

var INTERSECT_CUBIC_LINE_NO = INTERSECT_CUBIC_LINE_3 + 1;

1060

var INTERSECT_CUBIC_QUAD = INTERSECT_CUBIC_LINE_NO + 1;

1061

var INTERSECT_CUBIC_QUAD_2 = INTERSECT_CUBIC_QUAD + 1;

1062

var INTERSECT_CUBIC_QUAD_3 = INTERSECT_CUBIC_QUAD_2 + 1;

1063

var INTERSECT_CUBIC_QUAD_4 = INTERSECT_CUBIC_QUAD_3 + 1;

1064

var INTERSECT_CUBIC_QUAD_NO = INTERSECT_CUBIC_QUAD_4 + 1;

1065

var INTERSECT_CUBIC = INTERSECT_CUBIC_QUAD_NO + 1;

1066

var INTERSECT_CUBIC_2 = INTERSECT_CUBIC + 1;

1067

var INTERSECT_CUBIC_3 = INTERSECT_CUBIC_2 + 1;

1068

var INTERSECT_CUBIC_4 = INTERSECT_CUBIC_3 + 1;

1069

// FIXME: add cubic 5- 9

1070

var INTERSECT_CUBIC_NO = INTERSECT_CUBIC_4 + 1;

1071

1072

var SORT_UNARY = INTERSECT_CUBIC_NO + 1;

1073

var SORT_BINARY = SORT_UNARY + 1;

1074

1075

var OP_DIFFERENCE = SORT_BINARY + 1;

1076

var OP_INTERSECT = OP_DIFFERENCE + 1;

1077

var OP_UNION = OP_INTERSECT + 1;

1078

var OP_XOR = OP_UNION + 1;

1079

1080

var MARK_LINE = OP_XOR + 1;

1081

var MARK_QUAD = MARK_LINE + 1;

caryclark

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

[diff] [blame]

1082

var MARK_CONIC = MARK_QUAD + 1;

1083

var MARK_CUBIC = MARK_CONIC + 1;

caryclark

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

[diff] [blame]

1084

var MARK_DONE_LINE = MARK_CUBIC + 1;

1085

var MARK_DONE_QUAD = MARK_DONE_LINE + 1;

caryclark

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

[diff] [blame]

1086

var MARK_DONE_CONIC = MARK_DONE_QUAD + 1;

1087

var MARK_DONE_CUBIC = MARK_DONE_CONIC + 1;

caryclark

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

[diff] [blame]

1088

var MARK_UNSORTABLE_LINE = MARK_DONE_CUBIC + 1;

1089

var MARK_UNSORTABLE_QUAD = MARK_UNSORTABLE_LINE + 1;

caryclark

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

[diff] [blame]

1090

var MARK_UNSORTABLE_CONIC = MARK_UNSORTABLE_QUAD + 1;

1091

var MARK_UNSORTABLE_CUBIC = MARK_UNSORTABLE_CONIC + 1;

caryclark

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

[diff] [blame]

1092

var MARK_SIMPLE_LINE = MARK_UNSORTABLE_CUBIC + 1;

1093

var MARK_SIMPLE_QUAD = MARK_SIMPLE_LINE + 1;

caryclark

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

[diff] [blame]

1094

var MARK_SIMPLE_CONIC = MARK_SIMPLE_QUAD + 1;

1095

var MARK_SIMPLE_CUBIC = MARK_SIMPLE_CONIC + 1;

caryclark

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

[diff] [blame]

1096

var MARK_SIMPLE_DONE_LINE = MARK_SIMPLE_CUBIC + 1;

1097

var MARK_SIMPLE_DONE_QUAD = MARK_SIMPLE_DONE_LINE + 1;

caryclark

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

[diff] [blame]

1098

var MARK_SIMPLE_DONE_CONIC = MARK_SIMPLE_DONE_QUAD + 1;

1099

var MARK_SIMPLE_DONE_CUBIC = MARK_SIMPLE_DONE_CONIC + 1;

caryclark

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

[diff] [blame]

1100

var MARK_DONE_UNARY_LINE = MARK_SIMPLE_DONE_CUBIC + 1;

1101

var MARK_DONE_UNARY_QUAD = MARK_DONE_UNARY_LINE + 1;

caryclark

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

[diff] [blame]

1102

var MARK_DONE_UNARY_CONIC = MARK_DONE_UNARY_QUAD + 1;

1103

var MARK_DONE_UNARY_CUBIC = MARK_DONE_UNARY_CONIC + 1;

caryclark

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

[diff] [blame]

1104

var MARK_ANGLE_LAST = MARK_DONE_UNARY_CUBIC + 1;

1105

1106

var COMPUTED_SET_1 = MARK_ANGLE_LAST + 1;

1107

var COMPUTED_SET_2 = COMPUTED_SET_1 + 1;

1108

caryclark

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

[diff] [blame]

1109

var ANGLE_AFTER = COMPUTED_SET_2 + 1;

caryclark

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

[diff] [blame]

1110

var ANGLE_AFTERPART = ANGLE_AFTER + 1;

caryclark

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

[diff] [blame]

1111

caryclark

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

[diff] [blame]

1112

var ACTIVE_OP = ANGLE_AFTERPART + 1;

caryclark

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

[diff] [blame]

1113

caryclark

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

[diff] [blame]

1114

var COIN_MAIN_SPAN = ACTIVE_OP + 1;

1115

var COIN_OPP_SPAN = COIN_MAIN_SPAN + 1;

1116

1117

var FRAG_TYPE_LAST = COIN_OPP_SPAN;

caryclark

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

[diff] [blame]

1118

1119

var REC_TYPE_UNKNOWN = -1;

1120

var REC_TYPE_PATH = 0;

caryclark

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

[diff] [blame]

1121

var REC_TYPE_PATH2 = 1;

1122

var REC_TYPE_SECT = 2;

1123

var REC_TYPE_ACTIVE = 3;

1124

var REC_TYPE_ADD = 4;

1125

var REC_TYPE_SORT = 5;

1126

var REC_TYPE_OP = 6;

1127

var REC_TYPE_MARK = 7;

1128

var REC_TYPE_COMPUTED = 8;

1129

var REC_TYPE_COIN = 9;

1130

var REC_TYPE_ANGLE = 10;

1131

var REC_TYPE_ACTIVE_OP = 11;

1132

var REC_TYPE_AFTERPART = 12;

caryclark

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

[diff] [blame]

1133

var REC_TYPE_TOP = 13;

caryclark

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

[diff] [blame]

1134

var REC_TYPE_COINCIDENCE = 14;

caryclark

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

[diff] [blame]

1135

var REC_TYPE_ALIGNED = 15;

1136

var REC_TYPE_LAST = REC_TYPE_ALIGNED;

caryclark

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

[diff] [blame]

1137

1138

function strs_to_nums(strs) {

1139

var result = [];

1140

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

1141

var str = strs[idx];

1142

var num = parseFloat(str);

if (isNaN(num)) {

result.push(str);

} else {

result.push(num);

}

}

return result;

}

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

1153

if (regex.test(str)) {

1154

var strs = regex.exec(str);

1155

var result = strs_to_nums(strs);

array.push(id);

array.push(result);

return true;

}

return false;

}

function construct_regexp2(pattern) {

1164

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

1165

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

1166

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

caryclark

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

[diff] [blame]

1167

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

caryclark

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

[diff] [blame]

1168

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

1169

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

1170

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

caryclark

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

[diff] [blame]

1171

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

caryclark

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

[diff] [blame]

1172

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

1173

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

1174

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

caryclark

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

[diff] [blame]

1175

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

caryclark

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

[diff] [blame]

1176

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

caryclark

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

[diff] [blame]

1177

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

caryclark

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

[diff] [blame]

1178

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

1179

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

1180

return new RegExp(escape, 'i');

1181

}

1182

1183

function construct_regexp2c(pattern) {

1184

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

1185

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

caryclark

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

[diff] [blame]

1186

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]

1187

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]

1188

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

1189

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

caryclark

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

[diff] [blame]

1190

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

caryclark

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

[diff] [blame]

1191

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

caryclark

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

[diff] [blame]

1192

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

caryclark

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

[diff] [blame]

1193

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]

1194

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

caryclark

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

[diff] [blame]

1195

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

caryclark

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

[diff] [blame]

1196

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

1197

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

1198

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

caryclark

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

[diff] [blame]

1199

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

caryclark

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

[diff] [blame]

1200

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

1201

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

1202

return new RegExp(escape, 'i');

1203

}

1204

1205

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

1206

var regex = construct_regexp2(pattern);

1207

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

1208

return true;

1209

}

1210

regex = construct_regexp2c(pattern);

1211

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

1212

}

1213

1214

function endsWith(str, suffix) {

1215

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

1216

}

1217

1218

function parse_all(test) {

1219

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

1220

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

1221

var record = [];

1222

var recType = REC_TYPE_UNKNOWN;

1223

var lastLineNo;

1224

var moveX, moveY;

1225

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

1226

var line = lines[lineNo];

1227

if (line.length == 0) {

1228

continue;

1229

}

1230

var opStart = "SkOpSegment::";

1231

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

1232

line = line.substr(opStart.length);

1233

}

1234

var angleStart = "SkOpAngle::";

1235

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

1236

line = line.substr(angleStart.length);

1237

}

caryclark

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

[diff] [blame]

1238

var coinStart = "SkOpCoincidence::";

1239

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

1240

line = line.substr(coinStart.length);

1241

}

caryclark

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

[diff] [blame]

1242

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

caryclark

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

[diff] [blame]

1243

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

caryclark

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

[diff] [blame]

1244

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

caryclark

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

[diff] [blame]

1245

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

caryclark

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

[diff] [blame]

1246

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

caryclark

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

[diff] [blame]

1247

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

1248

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

1249

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

1250

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

caryclark

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

[diff] [blame]

1251

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

caryclark

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

[diff] [blame]

1252

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

caryclark

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

[diff] [blame]

1253

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

caryclark

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

[diff] [blame]

1254

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

1255

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

1256

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

1257

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

1258

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

caryclark

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

[diff] [blame]

1259

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

caryclark

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

[diff] [blame]

1260

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

1261

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

1262

: REC_TYPE_UNKNOWN;

1263

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

1264

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

1265

if (recType != REC_TYPE_UNKNOWN) {

1266

records.push(recType);

1267

records.push(lastLineNo);

1268

records.push(record);

}

record = [];

recType = type;

lastLineNo = lineNo;

}

var found = false;

switch (recType) {

case REC_TYPE_ACTIVE:

1277

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

caryclark

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

[diff] [blame]

1278

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

caryclark

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

[diff] [blame]

1279

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

caryclark

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

[diff] [blame]

1280

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

caryclark

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

[diff] [blame]

1281

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

caryclark

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

[diff] [blame]

1282

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

caryclark

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

[diff] [blame]

1283

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

caryclark

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

[diff] [blame]

1284

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

1285

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

1286

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

1287

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

1288

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

1289

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

1290

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

1291

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

1292

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

caryclark

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

[diff] [blame]

1293

);

1294

break;

1295

case REC_TYPE_ACTIVE_OP:

1296

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

1297

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

1302

moveX = record[1][0];

1303

moveY = record[1][1];

1304

found = true;

1305

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

1306

record[1].unshift(moveY);

1307

record[1].unshift(moveX);

1308

moveX = record[1][2];

1309

moveY = record[1][3];

1310

found = true;

1311

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

1312

record[1].unshift(moveY);

1313

record[1].unshift(moveX);

1314

moveX = record[1][4];

1315

moveY = record[1][5];

1316

found = true;

caryclark

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

[diff] [blame]

1317

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

1318

record[1].unshift(moveY);

1319

record[1].unshift(moveX);

1320

moveX = record[1][4];

1321

moveY = record[1][5];

1322

found = true;

caryclark

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

[diff] [blame]

1323

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

1324

record[1].unshift(moveY);

1325

record[1].unshift(moveX);

1326

moveX = record[1][6];

1327

moveY = record[1][7];

1328

found = true;

1329

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

1330

found = true;

1331

} else {

1332

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

1333

}

1334

break;

caryclark

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

[diff] [blame]

1335

case REC_TYPE_AFTERPART:

1336

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

1337

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

caryclark

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

[diff] [blame]

1338

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

caryclark

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

[diff] [blame]

1339

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

1340

break;

caryclark

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

[diff] [blame]

1341

case REC_TYPE_ALIGNED:

1342

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

1343

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

1344

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

1345

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

1346

);

1347

break;

caryclark

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

[diff] [blame]

1348

case REC_TYPE_ANGLE:

1349

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

caryclark

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

[diff] [blame]

1350

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

1355

case REC_TYPE_COINCIDENCE:

1356

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

1357

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

1358

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

1359

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

1360

);

1361

break;

caryclark

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

[diff] [blame]

1362

case REC_TYPE_COMPUTED:

1363

found = line == "computed quadratics given"

1364

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

1365

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

1366

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

caryclark

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

[diff] [blame]

1367

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

caryclark

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

[diff] [blame]

1368

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

1369

);

1370

break;

1371

case REC_TYPE_PATH:

caryclark

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

[diff] [blame]

1372

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

1373

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

caryclark

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

[diff] [blame]

1374

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

caryclark

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

[diff] [blame]

1375

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

1380

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

caryclark

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

[diff] [blame]

1381

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

caryclark

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

[diff] [blame]

1382

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

1387

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

1388

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

1389

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

1390

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

1391

" no intersect LINE_VAL LINE_VAL"

1392

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

1393

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

1394

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

1395

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

1396

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

1397

" no intersect QUAD_VAL LINE_VAL"

1398

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

1399

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

1400

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

1401

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

1402

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

1403

" no intersect QUAD_VAL QUAD_VAL"

caryclark

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

[diff] [blame]

1404

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

1405

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

1406

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

1407

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

1408

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

1409

" no intersect CONIC_VAL LINE_VAL"

1410

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

1411

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

1412

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

1413

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

1414

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

1415

" no intersect CONIC_VAL CONIC_VAL"

caryclark

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

[diff] [blame]

1416

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

1417

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

1418

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

1419

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

1420

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

1421

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

1422

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

1423

" no intersect CUBIC_VAL LINE_VAL"

1424

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

1425

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

1426

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

1427

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

1428

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

1429

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

1430

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

1431

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

1432

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

1433

" no intersect CUBIC_VAL QUAD_VAL"

1434

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

1435

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

1436

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

1437

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

1438

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

1439

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

1440

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

1441

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

1442

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

1443

" no intersect CUBIC_VAL CUBIC_VAL"

1444

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

1445

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

1446

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

1447

" no self intersect CUBIC_VAL"

);

break;

case REC_TYPE_SORT:

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

1452

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

1453

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

1454

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

1455

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

1456

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

1457

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

1458

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

1459

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

1460

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

1461

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

1462

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

1463

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

1464

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

1465

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

1466

);

1467

if (found) {

1468

record[1].push(hasDone);

1469

record[1].push(hasUnorderable);

1470

record[1].push(hasSmall);

1471

record[1].push(hasTiny);

1472

record[1].push(hasOperand);

1473

record[1].push(hasStop);

1474

}

1475

break;

caryclark

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

[diff] [blame]

1476

case REC_TYPE_TOP:

1477

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

1478

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

1479

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

1480

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

1481

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

1482

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

1483

);

1484

break;

caryclark

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

[diff] [blame]

1485

case REC_TYPE_MARK:

1486

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

caryclark

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

[diff] [blame]

1487

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

1488

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

caryclark

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

[diff] [blame]

1489

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

1490

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

1491

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

1492

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

caryclark

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

[diff] [blame]

1493

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

1494

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

1495

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

1496

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

1497

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

1498

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

1499

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

1500

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

1501

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

1502

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

1503

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

1504

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

1505

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

1506

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

1507

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

1508

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

1509

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

1510

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

caryclark

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

[diff] [blame]

1511

" last segment=IDX span=IDX"

caryclark

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

[diff] [blame]

1512

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

1513

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

caryclark

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

[diff] [blame]

1514

break;

1515

case REC_TYPE_OP:

1516

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

1517

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

1518

found = true;

1519

break;

1520

}

caryclark

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

[diff] [blame]

1521

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

caryclark

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

[diff] [blame]

1522

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

caryclark

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

[diff] [blame]

1523

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

caryclark

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

[diff] [blame]

1524

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

1525

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

1526

);

1527

break;

1528

case REC_TYPE_UNKNOWN:

found = true;

break;

}

if (!found) {

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

1534

}

1535

}

1536

if (recType != REC_TYPE_UNKNOWN) {

1537

records.push(recType);

1538

records.push(lastLineNo);

1539

records.push(record);

1540

}

1541

if (records.length >= 1) {

1542

tests[testIndex] = records;

1543

testLines[testIndex] = lines;

}

}

function init(test) {

1548

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

1549

if (!canvas.getContext) return;

1550

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

1551

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

1552

var unscaledWidth = window.innerWidth - 20;

1553

var unscaledHeight = window.innerHeight - 20;

1554

screenWidth = unscaledWidth;

1555

screenHeight = unscaledHeight;

1556

canvas.width = unscaledWidth * resScale;

1557

canvas.height = unscaledHeight * resScale;

1558

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

1559

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

1560

if (resScale != 1) {

1561

ctx.scale(resScale, resScale);

}

xmin = Infinity;

xmax = -Infinity;

ymin = Infinity;

ymax = -Infinity;

caryclark

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

[diff] [blame]

1567

hasPath = hasAlignedPath = hasComputedPath = false;

caryclark

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

[diff] [blame]

1568

firstActiveSpan = -1;

1569

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

1570

var recType = test[tIndex];

1571

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

1572

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

1573

throw "stop execution";

1574

}

1575

var records = test[tIndex + 2];

1576

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

1577

var fragType = records[recordIndex];

1578

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

1579

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

1580

throw "stop execution";

1581

}

1582

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]

1588

case REC_TYPE_ALIGNED:

1589

hasAlignedPath = true;

caryclark

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

[diff] [blame]

1590

case REC_TYPE_COMPUTED:

1591

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

1592

break;

1593

}

caryclark

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

[diff] [blame]

1594

if (REC_TYPE_COMPUTED == recType) {

1595

hasComputedPath = true;

1596

}

caryclark

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

[diff] [blame]

1597

case REC_TYPE_PATH:

caryclark

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

[diff] [blame]

1598

first = 1;

caryclark

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

[diff] [blame]

1599

switch (fragType) {

1600

case PATH_LINE:

caryclark

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

[diff] [blame]

1601

last = 5;

caryclark

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

[diff] [blame]

1602

break;

caryclark

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

[diff] [blame]

1603

case PATH_CONIC:

caryclark

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

[diff] [blame]

1604

case PATH_QUAD:

caryclark

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

[diff] [blame]

1605

last = 7;

caryclark

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

[diff] [blame]

1606

break;

1607

case PATH_CUBIC:

caryclark

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

[diff] [blame]

1608

last = 9;

caryclark

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

[diff] [blame]

1609

break;

1610

default:

1611

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

1612

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

1613

throw "stop execution";

1614

}

1615

if (recType == REC_TYPE_PATH) {

1616

hasPath = true;

1617

}

1618

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]

1625

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:

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

1634

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

1635

throw "stop execution";

1636

}

1637

if (recType == REC_TYPE_PATH2) {

1638

hasPath = true;

1639

}

1640

break;

caryclark

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

[diff] [blame]

1641

case REC_TYPE_ACTIVE:

1642

if (firstActiveSpan < 0) {

1643

firstActiveSpan = tIndex;

}

first = 1;

switch (fragType) {

case ACTIVE_LINE_SPAN:

1648

last = 5;

1649

break;

caryclark

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

[diff] [blame]

1650

case ACTIVE_CONIC_SPAN:

caryclark

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

[diff] [blame]

1651

case ACTIVE_QUAD_SPAN:

1652

last = 7;

1653

break;

1654

case ACTIVE_CUBIC_SPAN:

last = 9;

break;

default:

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

1659

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]

1669

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

1681

throw "stop execution";

1682

}

1683

break;

caryclark

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

[diff] [blame]

1684

case REC_TYPE_AFTERPART:

switch (fragType) {

case PATH_LINE:

last = 4;

break;

caryclark

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

[diff] [blame]

1689

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

1698

throw "stop execution";

1699

}

1700

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;

1705

break;

1706

case INTERSECT_LINE_2:

1707

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

1708

break;

1709

case INTERSECT_LINE_NO:

1710

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

1711

break;

caryclark

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

[diff] [blame]

1712

case INTERSECT_CONIC_LINE:

1713

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

1714

break;

caryclark

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

[diff] [blame]

1715

case INTERSECT_QUAD_LINE:

1716

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

1717

break;

caryclark

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

[diff] [blame]

1718

case INTERSECT_CONIC_LINE_2:

1719

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

1720

break;

caryclark

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

[diff] [blame]

1721

case INTERSECT_QUAD_LINE_2:

1722

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

1723

break;

caryclark

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

[diff] [blame]

1724

case INTERSECT_CONIC_LINE_NO:

1725

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

1726

break;

caryclark

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

[diff] [blame]

1727

case INTERSECT_QUAD_LINE_NO:

1728

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

1729

break;

caryclark

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

[diff] [blame]

1730

case INTERSECT_CONIC:

1731

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

1732

break;

caryclark

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

[diff] [blame]

1733

case INTERSECT_QUAD:

1734

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

1735

break;

caryclark

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

[diff] [blame]

1736

case INTERSECT_CONIC_2:

1737

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

1738

break;

caryclark

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

[diff] [blame]

1739

case INTERSECT_QUAD_2:

1740

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

1741

break;

caryclark

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

[diff] [blame]

1742

case INTERSECT_CONIC_NO:

1743

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

1744

break;

caryclark

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

[diff] [blame]

1745

case INTERSECT_QUAD_NO:

1746

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

1747

break;

1748

case INTERSECT_SELF_CUBIC:

1749

first = 1; last = 9;

1750

break;

1751

case INTERSECT_SELF_CUBIC_NO:

1752

first = 0; last = 8;

1753

break;

1754

case INTERSECT_CUBIC_LINE:

1755

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

1756

break;

1757

case INTERSECT_CUBIC_LINE_2:

1758

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

1759

break;

1760

case INTERSECT_CUBIC_LINE_3:

1761

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

1762

break;

1763

case INTERSECT_CUBIC_LINE_NO:

1764

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

1765

break;

1766

case INTERSECT_CUBIC_QUAD:

1767

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

1768

break;

1769

case INTERSECT_CUBIC_QUAD_2:

1770

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

1771

break;

1772

case INTERSECT_CUBIC_QUAD_3:

1773

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

1774

break;

1775

case INTERSECT_CUBIC_QUAD_4:

1776

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

1777

break;

1778

case INTERSECT_CUBIC_QUAD_NO:

1779

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

1780

break;

1781

case INTERSECT_CUBIC:

1782

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

1783

break;

1784

case INTERSECT_CUBIC_2:

1785

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

1786

break;

1787

case INTERSECT_CUBIC_3:

1788

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

1789

break;

1790

case INTERSECT_CUBIC_4:

1791

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

1792

break;

1793

case INTERSECT_CUBIC_NO:

1794

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

1795

break;

1796

default:

1797

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

1798

throw "stop execution";

}

break;

default:

continue;

}

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

1805

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

1806

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

1807

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

1808

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

1809

}

1810

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

1811

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

1812

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

1813

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

1814

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

}

}

}

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

1819

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

1820

var recType = test[tIndex];

1821

var records = test[tIndex + 2];

1822

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

1823

var fragType = records[recordIndex];

1824

var frags = records[recordIndex + 1];

1825

switch (recType) {

1826

case REC_TYPE_ACTIVE_OP:

if (!draw_op) {

break;

}

{

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

1832

curve_extremes(curve, angleBounds);

}

break;

case REC_TYPE_ANGLE:

if (!draw_angle) {

break;

}

caryclark

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

[diff] [blame]

1839

{

caryclark

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

[diff] [blame]

1840

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

1841

curve_extremes(curve, angleBounds);

1842

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

1843

curve_extremes(curve, angleBounds);

1844

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

1845

}

1846

break;

caryclark

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

[diff] [blame]

1847

case REC_TYPE_COINCIDENCE:

1848

if (!draw_coincidence) {

break;

}

{

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

1853

curve_extremes(curve, angleBounds);

1854

}

1855

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

1861

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

1862

curve_extremes(curve, angleBounds);

1863

}

1864

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

1871

curve_extremes(curve, angleBounds);

1872

}

1873

break;

caryclark

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

[diff] [blame]

}

}

}

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

1878

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

1879

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

1880

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

1881

setScale(xmin, xmax, ymin, ymax);

1882

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

caryclark

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

[diff] [blame]

1883

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

caryclark

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

[diff] [blame]

1884

}

1885

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

draw_computed = 0;

}

}

caryclark

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

[diff] [blame]

1890

function curveByIDMatch(test, id, recMatch) {

caryclark

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

[diff] [blame]

1891

var tIndex = -3;

1892

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

caryclark

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

[diff] [blame]

1893

var recType = test[tIndex];

caryclark

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

[diff] [blame]

1894

if (recType == REC_TYPE_OP) {

1895

continue;

1896

}

caryclark

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

[diff] [blame]

1897

if (recType != recMatch) {

caryclark

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

[diff] [blame]

1898

return [];

1899

}

1900

var records = test[tIndex + 2];

1901

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

1902

var fragType = records[recordIndex];

1903

var frags = records[recordIndex + 1];

1904

if (frags[0] == id) {

1905

switch (fragType) {

caryclark

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

[diff] [blame]

1906

case PATH_LINE:

caryclark

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

[diff] [blame]

1907

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

caryclark

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

[diff] [blame]

1908

case PATH_QUAD:

caryclark

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

[diff] [blame]

1909

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

1910

frags[5], frags[6]];

caryclark

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

[diff] [blame]

1911

case PATH_CONIC:

1912

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

1913

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

caryclark

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

[diff] [blame]

1914

case PATH_CUBIC:

caryclark

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

[diff] [blame]

1915

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

1916

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

1917

}

1918

}

1919

}

caryclark

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

[diff] [blame]

}

return [];

}

caryclark

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

[diff] [blame]

1924

function curveByID(test, id) {

1925

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

1926

if (!result.length) {

1927

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]

1933

var tIndex = -3;

1934

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

caryclark

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

[diff] [blame]

1935

var recType = test[tIndex];

caryclark

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

[diff] [blame]

1936

if (recType == REC_TYPE_OP) {

1937

continue;

1938

}

caryclark

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

[diff] [blame]

1939

if (recType != recMatch) {

caryclark

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

[diff] [blame]

1940

return [];

1941

}

1942

var records = test[tIndex + 2];

1943

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

1944

var fragType = records[recordIndex];

1945

var frags = records[recordIndex + 1];

1946

if (frags[0] == id) {

1947

switch (fragType) {

caryclark

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

[diff] [blame]

1948

case PATH_LINE:

caryclark

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

[diff] [blame]

1949

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

caryclark

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

[diff] [blame]

1950

case PATH_QUAD:

caryclark

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

[diff] [blame]

1951

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

1952

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

caryclark

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

[diff] [blame]

1953

case PATH_CONIC:

1954

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

1955

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

caryclark

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

[diff] [blame]

1956

case PATH_CUBIC:

caryclark

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

[diff] [blame]

1957

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

1958

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

1959

}

1960

}

1961

}

caryclark

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

[diff] [blame]

}

return [];

}

caryclark

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

[diff] [blame]

1966

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

1967

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

1968

if (!result.length) {

1969

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]

1975

var tIndex = 0;

caryclark

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

[diff] [blame]

1976

while (tIndex < test.length) {

1977

var recType = test[tIndex];

caryclark

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

[diff] [blame]

1978

if (recType != recMatch) {

caryclark

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

[diff] [blame]

1979

++tIndex;

1980

continue;

caryclark

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

[diff] [blame]

1981

}

1982

var records = test[tIndex + 2];

1983

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

1984

var fragType = records[recordIndex];

1985

var frags = records[recordIndex + 1];

caryclark

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

[diff] [blame]

1986

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

1987

continue;

1988

}

caryclark

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

[diff] [blame]

1989

switch (fragType) {

caryclark

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

[diff] [blame]

1990

case PATH_LINE:

caryclark

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

[diff] [blame]

1991

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

1992

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

1993

continue;

1994

}

1995

return frags[0];

caryclark

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

[diff] [blame]

1996

case PATH_QUAD:

caryclark

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

[diff] [blame]

1997

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

1998

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

1999

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

2000

continue;

2001

}

2002

return frags[0];

caryclark

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

[diff] [blame]

2003

case PATH_CONIC:

2004

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

2005

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

2006

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

2007

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

2008

continue;

2009

}

2010

return frags[0];

caryclark

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

[diff] [blame]

2011

case PATH_CUBIC:

caryclark

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

[diff] [blame]

2012

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

2013

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

2014

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

2015

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

2026

function idByCurve(test, frag, type) {

2027

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

2028

if (!result.length) {

2029

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

}

return result;

}

caryclark

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

[diff] [blame]

2034

function curve_extremes(curve, bounds) {

caryclark

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

[diff] [blame]

2035

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

caryclark

ed0935a

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

[diff] [blame]

2036

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

caryclark

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

[diff] [blame]

2037

var x = curve[index];

2038

var y = curve[index + 1];

2039

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

2040

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

2041

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

2042

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

}

}

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

2047

var srcWidth = x1 - x0;

2048

var srcHeight = y1 - y0;

2049

var usableWidth = screenWidth;

2050

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

2051

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

2052

usableWidth -= (xDigits + yDigits) * 10;

2053

usableWidth -= decimal_places * 10;

if (draw_legend) {

usableWidth -= 40;

}

var hscale = usableWidth / srcWidth;

2058

var vscale = screenHeight / srcHeight;

2059

scale = Math.min(hscale, vscale);

2060

var invScale = 1 / scale;

2061

var sxmin = x0 - invScale * 5;

2062

var symin = y0 - invScale * 10;

2063

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

2064

var symax = y1 + invScale * 10;

2065

srcWidth = sxmax - sxmin;

2066

srcHeight = symax - symin;

2067

hscale = usableWidth / srcWidth;

2068

vscale = screenHeight / srcHeight;

2069

scale = Math.min(hscale, vscale);

srcLeft = sxmin;

srcTop = symin;

}

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

2075

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

2076

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

2077

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

2078

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

2079

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

2080

var _dist = dist * scale;

2081

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

2082

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

2083

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

var divisor = 4;

var endDist;

do {

var ends = [];

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

2089

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

2090

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

ends.push(px);

ends.push(py);

}

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

2095

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

2096

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

2109

ctx.beginPath();

2110

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

2111

ctx.stroke();

2112

var saveAlign = ctx.textAlign;

2113

var saveStyle = ctx.fillStyle;

2114

var saveFont = ctx.font;

2115

ctx.textAlign = "center";

2116

ctx.fillStyle = "black";

2117

ctx.font = "normal 24px Arial";

2118

divisor *= 0.8;

2119

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

2120

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

2121

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

2122

var _px = (px - srcLeft) * scale;

2123

var _py = (py - srcTop) * scale;

2124

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

2125

}

2126

ctx.textAlign = saveAlign;

2127

ctx.fillStyle = saveStyle;

ctx.font = saveFont;

}

function drawPoint(px, py, end) {

caryclark

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

[diff] [blame]

2132

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

2133

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

caryclark

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

[diff] [blame]

2134

var x = drawnPts[pts];

2135

var y = drawnPts[pts + 1];

2136

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

return;

}

}

drawnPts.push(px);

drawnPts.push(py);

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

2143

var _px = (px - srcLeft) * scale;

2144

var _py = (py - srcTop) * scale;

2145

ctx.beginPath();

2146

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

2155

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

}

}

caryclark

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

[diff] [blame]

2159

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]

2173

function drawPoints(ptArray, curveType, drawControls) {

caryclark

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

[diff] [blame]

2174

var count = coordCount(curveType);

caryclark

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

[diff] [blame]

2175

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

2176

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

2177

continue;

2178

}

2179

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

}

}

function drawControlLines(curve, curveType, drawEnd) {

2184

if (curveType == PATH_LINE) {

2185

return;

2186

}

2187

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

2188

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

2189

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

2190

if (curveType == PATH_CUBIC) {

2191

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

2192

if (drawEnd > 1) {

2193

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

2194

if (drawEnd > 2) {

2195

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

2196

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

2197

}

2198

}

2199

} else if (drawEnd > 1) {

2200

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

2211

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

break;

case PATH_QUAD:

var one_t = 1 - t;

var a = one_t * one_t;

2216

var b = 2 * one_t * t;

2217

var c = t * t;

2218

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

2219

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

2220

break;

caryclark

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

[diff] [blame]

2221

case PATH_CONIC:

2222

var one_t = 1 - t;

2223

var a = one_t * one_t;

2224

var b = 2 * one_t * t;

2225

var c = t * t;

2226

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

2227

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

2228

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

2229

xy.x /= d;

2230

xy.y /= d;

2231

break;

caryclark

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

[diff] [blame]

2232

case PATH_CUBIC:

2233

var one_t = 1 - t;

2234

var one_t2 = one_t * one_t;

2235

var a = one_t2 * one_t;

2236

var b = 3 * one_t2 * t;

2237

var t2 = t * t;

2238

var c = 3 * one_t * t2;

2239

var d = t2 * t;

2240

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

2241

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

break;

}

return xy;

}

function drawPointAtT(curve, curveType) {

2248

var x, y;

2249

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

2250

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

2251

if (!draw_intersectT) {

2252

return;

2253

}

2254

ctx.fillStyle = "red";

2255

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

2256

}

2257

2258

function drawTAtPointUp(px, py, t) {

2259

var label = t.toFixed(decimal_places);

2260

var _px = (px - srcLeft)* scale;

2261

var _py = (py - srcTop) * scale;

2262

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

2263

}

2264

2265

function drawTAtPointDown(px, py, t) {

2266

var label = t.toFixed(decimal_places);

2267

var _px = (px - srcLeft)* scale;

2268

var _py = (py - srcTop) * scale;

2269

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

2270

}

2271

2272

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

2273

if (collect_bounds) {

2274

if (focus_enabled) {

2275

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

2276

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

2277

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

2278

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

}

return true;

}

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

2283

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

2284

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

2296

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

return;

}

ctx.beginPath();

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

2301

(y1 - srcTop) * scale);

2302

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

2303

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

2320

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,

2330

(ay - srcTop) * scale);

2331

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

2332

(by - srcTop) * scale);

ctx.stroke();

}

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

2337

if (collect_bounds) {

2338

if (focus_enabled) {

2339

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

2340

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

2341

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

2342

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

}

return true;

}

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

2347

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

2348

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

2349

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

2363

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

return;

}

ctx.beginPath();

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

2368

(y1 - srcTop) * scale);

2369

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

2370

(y2 - srcTop) * scale,

2371

(x3 - srcLeft) * scale,

2372

(y3 - srcTop) * scale);

ctx.stroke();

}

function interp(A, B, t) {

2377

return A + (B - A) * t;

2378

}

2379

2380

function interp_quad_coords(x1, x2, x3, t)

2381

{

2382

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

2383

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

2384

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

return abc;

}

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

2389

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

2390

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

2391

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

2392

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

2393

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

2394

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

2395

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

2396

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

2397

var array = [

2398

ax, ay, bx, by, cx, cy

];

return array;

}

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

2404

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,

2416

(ay - srcTop) * scale);

2417

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

2418

(by - srcTop) * scale,

2419

(cx - srcLeft) * scale,

2420

(cy - srcTop) * scale);

ctx.stroke();

}

caryclark

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

[diff] [blame]

2424

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

2425

if (collect_bounds) {

2426

if (focus_enabled) {

2427

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

2428

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

2429

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

2430

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

}

return true;

}

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

2435

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

2436

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

2437

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

2438

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

return true;

}

}

drawnConics.push(x1);

2443

drawnConics.push(y1);

2444

drawnConics.push(x2);

2445

drawnConics.push(y2);

2446

drawnConics.push(x3);

2447

drawnConics.push(y3);

drawnCubics.push(w);

return false;

}

var kMaxConicToQuadPOW2 = 5;

2453

2454

function computeQuadPOW2(curve, tol) {

2455

var a = curve[6] - 1;

2456

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

2457

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

2458

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

2459

2460

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

2461

var pow2;

2462

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

if (error <= tol) {

break;

}

error *= 0.25;

}

return pow2;

}

function subdivide_w_value(w) {

2472

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

2473

}

2474

2475

function chop(curve, part1, part2) {

2476

var w = curve[6];

2477

var scale = 1 / (1 + w);

2478

part1[0] = curve[0];

2479

part1[1] = curve[1];

2480

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

2481

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

2482

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

2483

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

2484

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

2485

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

2486

part2[4] = curve[4];

2487

part2[5] = curve[5];

2488

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

2489

}

2490

2491

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

2499

chop(curve, part1, part2);

2500

--level;

2501

subdivide(part1, level, pts);

2502

subdivide(part2, level, pts);

}

}

function chopIntoQuadsPOW2(curve, pow2, pts) {

2507

subdivide(curve, pow2, pts);

return 1 << pow2;

}

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

2512

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

return;

}

ctx.beginPath();

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

2517

(y1 - srcTop) * scale);

2518

var tol = 1 / scale;

2519

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

2520

var pow2 = computeQuadPOW2(curve, tol);

2521

var pts = [];

2522

chopIntoQuadsPOW2(curve, pow2, pts);

2523

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

2524

ctx.quadraticCurveTo(

2525

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

2526

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

}

ctx.stroke();

}

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

2532

var src2w = x2 * w;

2533

var C = x1;

2534

var A = x3 - 2 * src2w + C;

2535

var B = 2 * (src2w - C);

2536

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;

2545

}

2546

2547

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

2548

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

2549

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

2550

var az = conic_eval_denominator(w, t1);

2551

var midT = (t1 + t2) / 2;

2552

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

2553

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

2554

var dz = conic_eval_denominator(w, midT);

2555

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

2556

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

2557

var cz = conic_eval_denominator(w, t2);

2558

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

2559

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

2560

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

2561

var dt = t2 - t1;

2562

var dt_1 = 1 - dt;

caryclark

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

[diff] [blame]

2563

var array = [

caryclark

ed0935a

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

[diff] [blame]

2564

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

caryclark

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

[diff] [blame]

2565

];

caryclark

ed0935a

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

[diff] [blame]

2566

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

2567

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

2568

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

2569

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

2570

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

2571

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

2572

array[6] = partW;

caryclark

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

[diff] [blame]

return array;

}

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

2577

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

2586

}

2587

caryclark

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

[diff] [blame]

2588

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

2589

if (collect_bounds) {

2590

if (focus_enabled) {

2591

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

2592

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

2593

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

2594

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

}

return true;

}

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

2599

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

2600

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

2601

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

2602

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

return true;

}

}

drawnCubics.push(x1);

2607

drawnCubics.push(y1);

2608

drawnCubics.push(x2);

2609

drawnCubics.push(y2);

2610

drawnCubics.push(x3);

2611

drawnCubics.push(y3);

2612

drawnCubics.push(x4);

2613

drawnCubics.push(y4);

return false;

}

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

2618

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

return;

}

ctx.beginPath();

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

2623

(y1 - srcTop) * scale);

2624

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

2625

(y2 - srcTop) * scale,

2626

(x3 - srcLeft) * scale,

2627

(y3 - srcTop) * scale,

2628

(x4 - srcLeft) * scale,

2629

(y4 - srcTop) * scale);

ctx.stroke();

}

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

2634

{

2635

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

2636

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

2637

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

2638

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

2639

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

2640

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

return abcd;

}

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

2645

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

2646

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

2647

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

2648

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

2649

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

2650

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

2651

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

2652

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

2653

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

2654

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

2655

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

2656

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

2657

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

2658

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

2659

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

2660

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

2661

var array = [

2662

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

];

return array;

}

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

2668

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,

2682

(ay - srcTop) * scale);

2683

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

2684

(by - srcTop) * scale,

2685

(cx - srcLeft) * scale,

2686

(cy - srcTop) * scale,

2687

(dx - srcLeft) * scale,

2688

(dy - srcTop) * scale);

ctx.stroke();

}

function drawCurve(c) {

2693

switch (c.length) {

2694

case 4:

2695

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

2696

break;

2697

case 6:

2698

drawQuad(c[0], c[1], c[2], c[3], c[4], c[5]);

2699

break;

caryclark

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

[diff] [blame]

2700

case 7:

2701

drawConicWithQuads(c[0], c[1], c[2], c[3], c[4], c[5], c[6]);

2702

break;

caryclark

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

[diff] [blame]

2703

case 8:

2704

drawCubic(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]);

break;

}

}

function boundsWidth(pts) {

2710

var min = pts[0];

2711

var max = pts[0];

caryclark

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

[diff] [blame]

2712

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

2713

for (var idx = 2; idx < length; idx += 2) {

caryclark

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

[diff] [blame]

2714

min = Math.min(min, pts[idx]);

2715

max = Math.max(max, pts[idx]);

}

return max - min;

}

function boundsHeight(pts) {

2721

var min = pts[1];

2722

var max = pts[1];

caryclark

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

[diff] [blame]

2723

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

2724

for (var idx = 3; idx < length; idx += 2) {

caryclark

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

[diff] [blame]

2725

min = Math.min(min, pts[idx]);

2726

max = Math.max(max, pts[idx]);

}

return max - min;

}

function tangent(pts) {

2732

var dx = pts[2] - pts[0];

2733

var dy = pts[3] - pts[1];

2734

if (dx == 0 && dy == 0 && pts.length > 4) {

2735

dx = pts[4] - pts[0];

2736

dy = pts[5] - pts[1];

caryclark

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

[diff] [blame]

2737

if (dx == 0 && dy == 0 && pts.length == 8) {

caryclark

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

[diff] [blame]

2738

dx = pts[6] - pts[0];

2739

dy = pts[7] - pts[1];

2740

}

2741

}

2742

return Math.atan2(-dy, dx);

2743

}

2744

2745

function hodograph(cubic) {

2746

var hodo = [];

2747

hodo[0] = 3 * (cubic[2] - cubic[0]);

2748

hodo[1] = 3 * (cubic[3] - cubic[1]);

2749

hodo[2] = 3 * (cubic[4] - cubic[2]);

2750

hodo[3] = 3 * (cubic[5] - cubic[3]);

2751

hodo[4] = 3 * (cubic[6] - cubic[4]);

2752

hodo[5] = 3 * (cubic[7] - cubic[5]);

return hodo;

}

function hodograph2(cubic) {

2757

var quad = hodograph(cubic);

2758

var hodo = [];

2759

hodo[0] = 2 * (quad[2] - quad[0]);

2760

hodo[1] = 2 * (quad[3] - quad[1]);

2761

hodo[2] = 2 * (quad[4] - quad[2]);

2762

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

2789

}

2790

2791

function add_valid_ts(s, realRoots, t) {

2792

var foundRoots = 0;

2793

for (var index = 0; index < realRoots; ++index) {

2794

var tValue = s[index];

2795

if (tValue >= 0 && tValue <= 1) {

2796

for (var idx2 = 0; idx2 < foundRoots; ++idx2) {

2797

if (t[idx2] != tValue) {

2798

t[foundRoots++] = tValue;

}

}

}

}

return foundRoots;

}

function quadraticRootsValidT(a, b, c, t) {

2807

var s = [];

2808

var realRoots = quadraticRootsReal(A, B, C, s);

2809

var foundRoots = add_valid_ts(s, realRoots, t);

2810

return foundRoots != 0;

2811

}

2812

2813

function find_cubic_inflections(cubic, tValues) {

2814

var Ax = src[2] - src[0];

2815

var Ay = src[3] - src[1];

2816

var Bx = src[4] - 2 * src[2] + src[0];

2817

var By = src[5] - 2 * src[3] + src[1];

2818

var Cx = src[6] + 3 * (src[2] - src[4]) - src[0];

2819

var Cy = src[7] + 3 * (src[3] - src[5]) - src[1];

2820

return quadraticRootsValidT(Bx * Cy - By * Cx, (Ax * Cy - Ay * Cx),

2821

Ax * By - Ay * Bx, tValues);

2822

}

2823

2824

function dxy_at_t(curve, type, t) {

2825

var dxy = {};

2826

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

2831

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

caryclark

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

[diff] [blame]

2832

} else if (type == PATH_CONIC) {

2833

var p20x = curve[4] - curve[0];

2834

var p20y = curve[5] - curve[1];

2835

var p10xw = (curve[2] - curve[0]) * curve[6];

2836

var p10yw = (curve[3] - curve[1]) * curve[6];

2837

var coeff0x = curve[6] * p20x - p20x;

2838

var coeff0y = curve[6] * p20y - p20y;

2839

var coeff1x = p20x - 2 * p10xw;

2840

var coeff1y = p20y - 2 * p10yw;

2841

dxy.x = t * (t * coeff0x + coeff1x) + p10xw;

2842

dxy.y = t * (t * coeff0y + coeff1y) + p10yw;

caryclark

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

[diff] [blame]

2843

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

2860

ctx.beginPath();

2861

ctx.arc(px, py, 8, 0, Math.PI*2, true);

2862

ctx.closePath();

2863

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

2864

ctx.lineWidth = num == 0 || num == 3 ? 2 : 1;

2865

ctx.stroke();

2866

ctx.fillStyle = "black";

2867

ctx.font = "normal 10px Arial";

2868

// ctx.rotate(0.001);

2869

ctx.fillText(num, px - 2, py + 3);

2870

// ctx.rotate(-0.001);

2871

}

2872

2873

function drawLabelX(ymin, num, loc) {

2874

var px = (loc - srcLeft) * scale;

2875

var py = (ymin - srcTop) * scale - 20;

2876

drawLabel(num, px, py);

2877

}

2878

2879

function drawLabelY(xmin, num, loc) {

2880

var px = (xmin - srcLeft) * scale - 20;

2881

var py = (loc - srcTop) * scale;

2882

drawLabel(num, px, py);

2883

}

2884

2885

function drawHodoOrigin(hx, hy, hMinX, hMinY, hMaxX, hMaxY) {

2886

ctx.beginPath();

2887

ctx.moveTo(hx, hy - 100);

2888

ctx.lineTo(hx, hy);

2889

ctx.strokeStyle = hMinY < 0 ? "green" : "blue";

ctx.stroke();

ctx.beginPath();

ctx.moveTo(hx, hy);

ctx.lineTo(hx, hy + 100);

2894

ctx.strokeStyle = hMaxY > 0 ? "green" : "blue";

2895

ctx.stroke();

2896

ctx.beginPath();

2897

ctx.moveTo(hx - 100, hy);

2898

ctx.lineTo(hx, hy);

2899

ctx.strokeStyle = hMinX < 0 ? "green" : "blue";

ctx.stroke();

ctx.beginPath();

ctx.moveTo(hx, hy);

ctx.lineTo(hx + 100, hy);

2904

ctx.strokeStyle = hMaxX > 0 ? "green" : "blue";

ctx.stroke();

}

function scalexy(x, y, mag) {

2909

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

return mag / length;

}

caryclark

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

[diff] [blame]

2913

function drawArrow(x, y, dx, dy, s) {

2914

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

2919

x += dx;

2920

y += dy;

2921

ctx.lineTo((x - srcLeft) * scale, (y - srcTop) * scale);

2922

dx /= 10;

2923

dy /= 10;

2924

ctx.lineTo((x - dy - srcLeft) * scale, (y + dx - srcTop) * scale);

2925

ctx.lineTo((x + dx * 2 - srcLeft) * scale, (y + dy * 2 - srcTop) * scale);

2926

ctx.lineTo((x + dy - srcLeft) * scale, (y - dx - srcTop) * scale);

2927

ctx.lineTo((x - srcLeft) * scale, (y - srcTop) * scale);

2928

ctx.strokeStyle = "rgba(0,75,0, 0.4)";

ctx.stroke();

}

function x_at_t(curve, t) {

2933

var one_t = 1 - t;

2934

if (curve.length == 4) {

2935

return one_t * curve[0] + t * curve[2];

2936

}

2937

var one_t2 = one_t * one_t;

2938

var t2 = t * t;

2939

if (curve.length == 6) {

2940

return one_t2 * curve[0] + 2 * one_t * t * curve[2] + t2 * curve[4];

2941

}

caryclark

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

[diff] [blame]

2942

if (curve.length == 7) {

2943

return (one_t2 * curve[0] + 2 * one_t * t * curve[2] * curve[6] + t2 * curve[4])

2944

/ (one_t2 +2 * one_t * t * curve[6] + t2);

2945

}

caryclark

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

[diff] [blame]

2946

var a = one_t2 * one_t;

2947

var b = 3 * one_t2 * t;

2948

var c = 3 * one_t * t2;

2949

var d = t2 * t;

2950

return a * curve[0] + b * curve[2] + c * curve[4] + d * curve[6];

2951

}

2952

2953

function y_at_t(curve, t) {

2954

var one_t = 1 - t;

2955

if (curve.length == 4) {

2956

return one_t * curve[1] + t * curve[3];

2957

}

2958

var one_t2 = one_t * one_t;

2959

var t2 = t * t;

2960

if (curve.length == 6) {

2961

return one_t2 * curve[1] + 2 * one_t * t * curve[3] + t2 * curve[5];

2962

}

caryclark

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

[diff] [blame]

2963

if (curve.length == 7) {

2964

return (one_t2 * curve[1] + 2 * one_t * t * curve[3] * curve[6] + t2 * curve[5])

2965

/ (one_t2 +2 * one_t * t * curve[6] + t2);

2966

}

caryclark

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

[diff] [blame]

2967

var a = one_t2 * one_t;

2968

var b = 3 * one_t2 * t;

2969

var c = 3 * one_t * t2;

2970

var d = t2 * t;

2971

return a * curve[1] + b * curve[3] + c * curve[5] + d * curve[7];

2972

}

2973

2974

function drawOrder(curve, label) {

2975

var px = x_at_t(curve, 0.75);

2976

var py = y_at_t(curve, 0.75);

2977

var _px = (px - srcLeft) * scale;

2978

var _py = (py - srcTop) * scale;

2979

ctx.beginPath();

2980

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

2981

ctx.closePath();

2982

ctx.fillStyle = "white";

2983

ctx.fill();

2984

if (label == 'L') {

2985

ctx.strokeStyle = "rgba(255,0,0, 1)";

2986

ctx.fillStyle = "rgba(255,0,0, 1)";

2987

} else {

2988

ctx.strokeStyle = "rgba(0,0,255, 1)";

2989

ctx.fillStyle = "rgba(0,0,255, 1)";

2990

}

2991

ctx.stroke();

2992

ctx.font = "normal 16px Arial";

2993

ctx.textAlign = "center";

2994

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

2995

ctx.font = "normal 10px Arial";

2996

}

2997

2998

function drawID(curve, id) {

2999

var px = x_at_t(curve, 0.5);

3000

var py = y_at_t(curve, 0.5);

3001

var _px = (px - srcLeft) * scale;

3002

var _py = (py - srcTop) * scale;

3003

draw_id_at(id, _px, _py);

3004

}

3005

3006

function draw_id_at(id, _px, _py) {

3007

ctx.beginPath();

3008

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

3009

ctx.closePath();

3010

ctx.fillStyle = "white";

3011

ctx.fill();

3012

ctx.strokeStyle = "rgba(127,127,0, 1)";

3013

ctx.fillStyle = "rgba(127,127,0, 1)";

3014

ctx.stroke();

3015

ctx.font = "normal 16px Arial";

3016

ctx.textAlign = "center";

3017

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

3018

ctx.font = "normal 10px Arial";

3019

}

3020

3021

function drawLinePartialID(id, x1, y1, x2, y2, t1, t2) {

3022

var curve = [x1, y1, x2, y2];

3023

drawCurvePartialID(id, curve, t1, t2);

3024

}

3025

3026

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

3027

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

3028

drawCurvePartialID(id, curve, t1, t2);

3029

}

3030

caryclark

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

[diff] [blame]

3031

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

3032

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

3033

drawCurvePartialID(id, curve, t1, t2);

3034

}

3035

caryclark

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

[diff] [blame]

3036

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

3037

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

3038

drawCurvePartialID(id, curve, t1, t2);

3039

}

3040

3041

function drawCurvePartialID(id, curve, t1, t2) {

3042

var px = x_at_t(curve, (t1 + t2) / 2);

3043

var py = y_at_t(curve, (t1 + t2) / 2);

3044

var _px = (px - srcLeft) * scale;

3045

var _py = (py - srcTop) * scale;

3046

draw_id_at(id, _px, _py);

3047

}

3048

3049

function drawCurveSpecials(test, curve, type) {

3050

if (pt_labels) {

3051

drawPoints(curve, type, pt_labels == 2);

3052

}

3053

if (control_lines != 0) {

3054

drawControlLines(curve, type, control_lines);

3055

}

3056

if (curve_t) {

3057

drawPointAtT(curve, type);

3058

}

3059

if (draw_midpoint) {

3060

var mid = pointAtT(curve, type, 0.5);

3061

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

3062

}

3063

if (draw_id) {

3064

var id = idByCurve(test, curve, type);

if (id >= 0) {

drawID(curve, id);

}

}

if (type == PATH_LINE) {

3070

return;

3071

}

3072

if (draw_deriviatives > 0) {

3073

var d = dxy_at_t(curve, type, 0);

caryclark

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

[diff] [blame]

3074

drawArrow(curve[0], curve[1], d.x, d.y, 1);

caryclark

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

[diff] [blame]

3075

if (draw_deriviatives == 2) {

3076

d = dxy_at_t(curve, type, 1);

3077

if (type == PATH_CUBIC) {

caryclark

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

[diff] [blame]

3078

drawArrow(curve[6], curve[7], d.x, d.y, 1);

caryclark

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

[diff] [blame]

3079

} else {

caryclark

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

[diff] [blame]

3080

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

3085

d = dxy_at_t(curve, type, 0.5);

caryclark

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

[diff] [blame]

3086

drawArrow(mid.x, mid.y, d.x, d.y, 1);

caryclark

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

[diff] [blame]

3087

}

3088

}

3089

if (type != PATH_CUBIC) {

3090

return;

3091

}

caryclark

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

[diff] [blame]

3092

if (draw_sequence) {

3093

var ymin = Math.min(curve[1], curve[3], curve[5], curve[7]);

3094

for (var i = 0; i < 8; i+= 2) {

3095

drawLabelX(ymin, i >> 1, curve[i]);

3096

}

3097

var xmin = Math.min(curve[0], curve[2], curve[4], curve[6]);

3098

for (var i = 1; i < 8; i+= 2) {

3099

drawLabelY(xmin, i >> 1, curve[i]);

}

}

}

function logCurves(test) {

3105

for (curves in test) {

3106

var curve = test[curves];

dumpCurve(curve);

}

}

function curveToString(curve) {

3112

var str = "{{";

caryclark

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

[diff] [blame]

3113

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

3114

if (curve.length == 7) {

3115

str += "{";

3116

}

3117

for (i = 0; i < length; i += 2) {

caryclark

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

[diff] [blame]

3118

str += curve[i].toFixed(decimal_places) + "," + curve[i + 1].toFixed(decimal_places);

3119

if (i < curve.length - 2) {

3120

str += "}, {";

3121

}

3122

}

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3123

str += "}";

3124

if (curve.length == 7) {

3125

str += "}, " + curve[6].toFixed(decimal_places);

3126

}

3127

str += "}";

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

return str;

}

function dumpCurve(curve) {

3132

console.log(curveToString(curve));

3133

}

3134

3135

function draw(test, lines, title) {

3136

ctx.fillStyle = "rgba(0,0,0, 0.1)";

3137

ctx.font = "normal 50px Arial";

3138

ctx.textAlign = "left";

3139

ctx.fillText(title, 50, 50);

3140

ctx.font = "normal 10px Arial";

3141

ctx.lineWidth = "1.001"; "0.999";

3142

var secondPath = test.length;

var closeCount = 0;

logStart = -1;

logRange = 0;

// find last active rec type at this step

3147

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]

3152

var lastCoin = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3153

var lastSect = 0;

3154

var lastSort = 0;

3155

var lastMark = 0;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3156

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]

3163

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]

3168

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]

3173

topMax = 0;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3174

markMax = 0;

3175

lastIndex = test.length - 3;

3176

for (var tIndex = 0; tIndex < test.length; tIndex += 3) {

3177

var recType = test[tIndex];

3178

if (!typeof recType == 'number' || recType < REC_TYPE_UNKNOWN || recType > REC_TYPE_LAST) {

3179

console.log("unknown rec type: " + recType);

3180

throw "stop execution";

3181

}

3182

// if (curType == recType && curType != REC_TYPE_ADD) {

3183

// continue;

3184

// }

3185

var inStepRange = step_limit == 0 || curStep < step_limit;

3186

curType = recType;

3187

if (recType == REC_TYPE_OP) {

hasOp = true;

continue;

}

if (recType == REC_TYPE_UNKNOWN) {

3192

// these types do not advance step

3193

continue;

3194

}

3195

var bumpStep = false;

3196

var records = test[tIndex + 2];

3197

var fragType = records[0];

3198

if (recType == REC_TYPE_ADD) {

3199

if (records.length != 2) {

3200

console.log("expect only two elements: " + records.length);

3201

throw "stop execution";

3202

}

3203

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) {

3215

secondPath = tIndex;

3216

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3217

if (recType == REC_TYPE_PATH2 && hasOp) {

3218

secondPath = tIndex;

3219

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3220

if (recType == REC_TYPE_ACTIVE) {

3221

++activeMax;

3222

if (!draw_active || !inStepRange) {

continue;

}

lastActive = tIndex;

++activeCount;

bumpStep = true;

}

if (recType == REC_TYPE_ACTIVE_OP) {

3230

++opMax;

3231

if (!draw_op || !inStepRange) {

continue;

}

lastOp = tIndex;

++opCount;

bumpStep = true;

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3238

if (recType == REC_TYPE_AFTERPART) {

3239

if (draw_angle != 3 || !inStepRange) {

continue;

}

lastAngle = tIndex;

++angleCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3246

if (recType == REC_TYPE_ANGLE) {

3247

++angleMax;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3248

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]

3255

if (recType == REC_TYPE_COINCIDENCE) {

3256

++coinMax;

3257

if (!draw_coincidence || !inStepRange) {

continue;

}

lastCoin = tIndex;

++coinCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3264

if (recType == REC_TYPE_SECT) {

3265

if (records.length != 2) {

3266

console.log("expect only two elements: " + records.length);

3267

throw "stop execution";

}

++sectMax;

var sectBump = 1;

switch (fragType) {

case INTERSECT_LINE:

case INTERSECT_QUAD_LINE:

3274

case INTERSECT_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3275

case INTERSECT_CONIC_LINE:

3276

case INTERSECT_CONIC:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3277

case INTERSECT_SELF_CUBIC:

3278

case INTERSECT_CUBIC_LINE:

3279

case INTERSECT_CUBIC_QUAD:

3280

case INTERSECT_CUBIC:

3281

sectBump = 1;

3282

break;

3283

case INTERSECT_LINE_2:

3284

case INTERSECT_QUAD_LINE_2:

3285

case INTERSECT_QUAD_2:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3286

case INTERSECT_CONIC_LINE_2:

3287

case INTERSECT_CONIC_2:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3288

case INTERSECT_CUBIC_LINE_2:

3289

case INTERSECT_CUBIC_QUAD_2:

3290

case INTERSECT_CUBIC_2:

3291

sectBump = 2;

3292

break;

3293

case INTERSECT_LINE_NO:

3294

case INTERSECT_QUAD_LINE_NO:

3295

case INTERSECT_QUAD_NO:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3296

case INTERSECT_CONIC_LINE_NO:

3297

case INTERSECT_CONIC_NO:

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3298

case INTERSECT_SELF_CUBIC_NO:

3299

case INTERSECT_CUBIC_LINE_NO:

3300

case INTERSECT_CUBIC_QUAD_NO:

3301

case INTERSECT_CUBIC_NO:

3302

sectBump = 0;

3303

break;

3304

case INTERSECT_CUBIC_LINE_3:

3305

case INTERSECT_CUBIC_QUAD_3:

3306

case INTERSECT_CUBIC_3:

3307

sectBump = 3;

3308

break;

3309

case INTERSECT_CUBIC_QUAD_4:

3310

case INTERSECT_CUBIC_4:

sectBump = 4;

break;

default:

console.log("missing case " + records.length);

3315

throw "stop execution";

3316

}

3317

sectMax2 += sectBump;

3318

if (draw_intersection <= 1 || !inStepRange) {

continue;

}

lastSect = tIndex;

sectCount += sectBump;

3323

bumpStep = true;

3324

}

3325

if (recType == REC_TYPE_SORT) {

3326

++sortMax;

3327

if (!draw_sort || !inStepRange) {

continue;

}

lastSort = tIndex;

++sortCount;

bumpStep = true;

}

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3334

if (recType == REC_TYPE_TOP) {

3335

++topMax;

3336

if (!draw_top || !inStepRange) {

continue;

}

lastTop = tIndex;

++topCount;

bumpStep = true;

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3343

if (recType == REC_TYPE_MARK) {

3344

++markMax;

3345

if (!draw_mark || !inStepRange) {

continue;

}

lastMark = tIndex;

++markCount;

bumpStep = true;

}

if (bumpStep) {

lastIndex = tIndex;

logStart = test[tIndex + 1];

3355

logRange = records.length / 2;

++curStep;

}

}

stepMax = (draw_add ? addMax : 0)

3360

+ (draw_active ? activeMax : 0)

reed

0dc4dd6

2015-03-24 13:55:33 -0700

[diff] [blame]

3361

+ (draw_angle ? angleMax : 0)

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3362

+ (draw_coincidence ? coinMax : 0)

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3363

+ (draw_op ? opMax : 0)

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3364

+ (draw_sort ? sortMax : 0)

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3365

+ (draw_top ? topMax : 0)

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3366

+ (draw_mark ? markMax : 0)

3367

+ (draw_intersection == 2 ? sectMax : draw_intersection == 3 ? sectMax2 : 0);

3368

if (stepMax == 0) {

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3369

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]

3374

drawnConics = [];

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3375

drawnCubics = [];

3376

focusXmin = focusYmin = Infinity;

3377

focusXmax = focusYmax = -Infinity;

3378

var pathIndex = 0;

3379

var opLetter = 'S';

3380

for (var tIndex = lastIndex; tIndex >= 0; tIndex -= 3) {

3381

var recType = test[tIndex];

3382

var records = test[tIndex + 2];

3383

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

3384

var fragType = records[recordIndex];

3385

if (!typeof fragType == 'number' || fragType < 1 || fragType > FRAG_TYPE_LAST) {

3386

console.log("unknown in range frag type: " + fragType);

3387

throw "stop execution";

3388

}

3389

var frags = records[recordIndex + 1];

3390

focus_enabled = false;

3391

switch (recType) {

3392

case REC_TYPE_COMPUTED:

3393

if (draw_computed == 0) {

continue;

}

ctx.lineWidth = 1;

ctx.strokeStyle = pathIndex == 0 ? "black" : "red";

3398

ctx.fillStyle = "blue";

3399

var drawThis = false;

3400

switch (fragType) {

3401

case PATH_QUAD:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3402

if ((draw_computed & 0x9) == 1 || ((draw_computed & 8) != 0

3403

&& (draw_computed & 7) == pathIndex)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3404

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]

3409

case PATH_CONIC:

3410

if ((draw_computed & 0xA) == 2 || ((draw_computed & 8) != 0

3411

&& (draw_computed & 7) == pathIndex)) {

3412

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

3413

frags[4], frags[5], frags[6]);

3414

drawThis = true;

3415

}

3416

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3417

case PATH_CUBIC:

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3418

if ((draw_computed & 0xC) == 4 || ((draw_computed & 8) != 0

3419

&& (draw_computed & 7) == pathIndex)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3420

drawCubic(frags[0], frags[1], frags[2], frags[3],

3421

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);

3434

throw "stop execution";

3435

}

3436

if (!drawThis || collect_bounds) {

3437

break;

3438

}

3439

drawCurveSpecials(test, frags, fragType);

3440

break;

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3441

case REC_TYPE_ALIGNED:

3442

if (draw_path < 4) {

3443

continue;

3444

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3445

case REC_TYPE_PATH:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3446

case REC_TYPE_PATH2:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3447

if (REC_TYPE_ALIGNED != recType && draw_path >= 4) {

3448

continue;

3449

}

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

if (!draw_path) {

continue;

}

var firstPath = tIndex < secondPath;

3454

if ((draw_path & (firstPath ? 1 : 2)) == 0) {

continue;

}

ctx.lineWidth = 1;

ctx.strokeStyle = firstPath ? "black" : "red";

3459

ctx.fillStyle = "blue";

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3460

var frags2 = [];

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3461

switch (fragType) {

3462

case PATH_LINE:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3463

for (var i = 0; i < 4; ++ i) { frags2[i] = frags[i + 1]; }

3464

drawLine(frags2[0], frags2[1], frags2[2], frags2[3]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3465

break;

3466

case PATH_QUAD:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3467

for (var i = 0; i < 6; ++ i) { frags2[i] = frags[i + 1]; }

3468

drawQuad(frags2[0], frags2[1], frags2[2], frags2[3],

3469

frags2[4], frags2[5]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3470

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3471

case PATH_CONIC:

3472

for (var i = 0; i < 7; ++ i) { frags2[i] = frags[i + 1]; }

3473

drawConicWithQuads(frags2[0], frags2[1], frags2[2], frags2[3],

3474

frags2[4], frags2[5], frags2[6]);

3475

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3476

case PATH_CUBIC:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3477

for (var i = 0; i < 8; ++ i) { frags2[i] = frags[i + 1]; }

3478

drawCubic(frags2[0], frags2[1], frags2[2], frags2[3],

3479

frags2[4], frags2[5], frags2[6], frags2[7]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3480

break;

3481

default:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

3482

console.log("unknown " + recType + " frag type: " + fragType);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3483

throw "stop execution";

3484

}

3485

if (collect_bounds) {

3486

break;

3487

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3488

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;

3493

case OP_DIFFERENCE: opLetter = 'D'; break;

3494

case OP_UNION: opLetter = 'U'; break;

3495

case OP_XOR: opLetter = 'X'; break;

3496

default:

3497

console.log("unknown REC_TYPE_OP frag type: " + fragType);

3498

throw "stop execution";

3499

}

3500

break;

3501

case REC_TYPE_ACTIVE:

3502

if (!draw_active || (step_limit > 0 && tIndex < lastActive)) {

3503

continue;

3504

}

3505

var x1 = frags[SPAN_X1];

3506

var y1 = frags[SPAN_Y1];

3507

var x2 = frags[SPAN_X2];

3508

var y2 = frags[SPAN_Y2];

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3509

var x3, y3, x3, y4, t1, t2, w;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3510

ctx.lineWidth = 3;

3511

ctx.strokeStyle = "rgba(0,0,255, 0.3)";

3512

focus_enabled = true;

3513

switch (fragType) {

3514

case ACTIVE_LINE_SPAN:

3515

t1 = frags[SPAN_L_T];

3516

t2 = frags[SPAN_L_TEND];

3517

drawLinePartial(x1, y1, x2, y2, t1, t2);

3518

if (draw_id) {

3519

drawLinePartialID(frags[0], x1, y1, x2, y2, t1, t2);

3520

}

3521

break;

3522

case ACTIVE_QUAD_SPAN:

3523

x3 = frags[SPAN_X3];

3524

y3 = frags[SPAN_Y3];

3525

t1 = frags[SPAN_Q_T];

3526

t2 = frags[SPAN_Q_TEND];

3527

drawQuadPartial(x1, y1, x2, y2, x3, y3, t1, t2);

3528

if (draw_id) {

3529

drawQuadPartialID(frags[0], x1, y1, x2, y2, x3, y3, t1, t2);

3530

}

3531

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3532

case ACTIVE_CONIC_SPAN:

3533

x3 = frags[SPAN_X3];

3534

y3 = frags[SPAN_Y3];

3535

t1 = frags[SPAN_K_T];

3536

t2 = frags[SPAN_K_TEND];

3537

w = frags[SPAN_K_W];

3538

drawConicPartial(x1, y1, x2, y2, x3, y3, w, t1, t2);

3539

if (draw_id) {

3540

drawConicPartialID(frags[0], x1, y1, x2, y2, x3, y3, w, t1, t2);

3541

}

3542

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3543

case ACTIVE_CUBIC_SPAN:

x3 = frags[SPAN_X3];

y3 = frags[SPAN_Y3];

x4 = frags[SPAN_X4];

y4 = frags[SPAN_Y4];

t1 = frags[SPAN_C_T];

3549

t2 = frags[SPAN_C_TEND];

3550

drawCubicPartial(x1, y1, x2, y2, x3, y3, x4, y4, t1, t2);

3551

if (draw_id) {

3552

drawCubicPartialID(frags[0], x1, y1, x2, y2, x3, y3, x4, y4, t1, t2);

}

break;

default:

console.log("unknown REC_TYPE_ACTIVE frag type: " + fragType);

3557

throw "stop execution";

3558

}

3559

break;

3560

case REC_TYPE_ACTIVE_OP:

3561

if (!draw_op || (step_limit > 0 && tIndex < lastOp)) {

3562

continue;

3563

}

3564

focus_enabled = true;

3565

ctx.lineWidth = 3;

3566

var activeSpan = frags[7] == "1";

3567

ctx.strokeStyle = activeSpan ? "rgba(45,160,0, 0.3)" : "rgba(255,45,0, 0.5)";

3568

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

3569

drawCurve(curve);

3570

if (draw_op > 1) {

3571

drawArc(curve, false, frags[3], frags[4]);

3572

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)"

3581

: closeCount == 1 ? "rgba(0,127,0, 0.3)"

3582

: closeCount == 2 ? "rgba(0,127,127, 0.3)"

3583

: closeCount == 3 ? "rgba(127,127,0, 0.3)"

3584

: "rgba(127,0,127, 0.3)";

3585

focus_enabled = true;

switch (fragType) {

case ADD_MOVETO:

break;

case ADD_LINETO:

if (step_limit == 0 || tIndex >= lastAdd) {

3591

drawLine(frags[0], frags[1], frags[2], frags[3]);

}

break;

case ADD_QUADTO:

if (step_limit == 0 || tIndex >= lastAdd) {

3596

drawQuad(frags[0], frags[1], frags[2], frags[3], frags[4], frags[5]);

3597

}

3598

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3599

case ADD_CONICTO:

3600

if (step_limit == 0 || tIndex >= lastAdd) {

3601

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

3602

frags[4], frags[5], frags[6]);

3603

}

3604

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3605

case ADD_CUBICTO:

3606

if (step_limit == 0 || tIndex >= lastAdd) {

3607

drawCubic(frags[0], frags[1], frags[2], frags[3],

3608

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);

3618

throw "stop execution";

3619

}

3620

break;

3621

case REC_TYPE_ANGLE:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3622

angleBetween = frags[18] == "T";

3623

afterIndex = 0;

3624

if (draw_angle == 0 || draw_angle == 3 || (step_limit > 0 && tIndex < lastAngle)) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3625

continue;

3626

}

3627

focus_enabled = true;

3628

ctx.lineWidth = 3;

3629

ctx.strokeStyle = "rgba(127,45,127, 0.3)";

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3630

var leftCurve = curvePartialByID(test, frags[0], frags[4], frags[5]);

3631

var midCurve = curvePartialByID(test, frags[6], frags[10], frags[11]);

3632

var rightCurve = curvePartialByID(test, frags[12], frags[16], frags[17]);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3633

drawCurve(leftCurve);

3634

drawCurve(rightCurve);

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3635

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]

3636

drawCurve(midCurve);

3637

if (draw_angle > 1) {

3638

drawOrder(leftCurve, 'L');

3639

drawOrder(rightCurve, 'R');

3640

}

3641

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3642

case REC_TYPE_AFTERPART:

3643

if (draw_angle != 3 || (step_limit > 0 && tIndex < lastAngle)) {

3644

continue;

3645

}

3646

ctx.strokeStyle = afterIndex == 0 ? "rgba(255,0,0, 1.0)"

3647

: (afterIndex == 1) == angleBetween ? "rgba(0,128,0, 1.0)"

3648

: "rgba(0,0,255, 1.0)";

3649

switch (fragType) {

3650

case PATH_LINE:

3651

drawLine(frags[0], frags[1], frags[2], frags[3]);

3652

break;

3653

case PATH_QUAD:

3654

drawQuad(frags[0], frags[1], frags[2], frags[3],

3655

frags[4], frags[5]);

3656

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3657

case PATH_CONIC:

3658

drawConicWithQuads(frags[0], frags[1], frags[2], frags[3],

3659

frags[4], frags[5], frags[6]);

3660

break;

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3661

case PATH_CUBIC:

3662

drawCubic(frags[0], frags[1], frags[2], frags[3],

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3663

frags[4], frags[5], frags[6], frags[7]);

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3664

break;

3665

default:

3666

console.log("unknown REC_TYPE_AFTERPART frag type: " + fragType);

3667

throw "stop execution";

3668

}

3669

++afterIndex;

3670

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

3671

case REC_TYPE_COINCIDENCE:

3672

if (!draw_coincidence || (step_limit > 0 && tIndex < lastCoin)) {

3673

continue;

3674

}

3675

focus_enabled = true;

3676

ctx.lineWidth = 3;

3677

ctx.strokeStyle = "rgba(127,45,63, 0.3)";

3678

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

3679

drawCurve(curve);

3680

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3681

case REC_TYPE_SECT:

3682

if (!draw_intersection) {

3683

continue;

3684

}

3685

if (draw_intersection != 1 && (step_limit > 0 && tIndex < lastSect)) {

3686

continue;

3687

}

3688

// draw_intersection == 1 : show all

3689

// draw_intersection == 2 : step == 0 ? show all : show intersection line #step

3690

// draw_intersection == 3 : step == 0 ? show all : show intersection #step

3691

ctx.lineWidth = 1;

3692

ctx.strokeStyle = "rgba(0,0,255, 0.3)";

3693

ctx.fillStyle = "blue";

3694

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;

3704

break;

3705

case INTERSECT_LINE_2:

3706

f.push(5, 6, 0, 10);

3707

f.push(8, 9, 7, 15);

3708

c1s = 1; c1l = 4; c2s = 11; c2l = 4;

3709

break;

3710

case INTERSECT_LINE_NO:

3711

c1s = 0; c1l = 4; c2s = 4; c2l = 4;

3712

break;

3713

case INTERSECT_QUAD_LINE:

3714

f.push(7, 8, 0, 9);

3715

c1s = 1; c1l = 6; c2s = 10; c2l = 4;

3716

break;

3717

case INTERSECT_QUAD_LINE_2:

3718

f.push(7, 8, 0, 12);

3719

f.push(10, 11, 9, 17);

3720

c1s = 1; c1l = 6; c2s = 13; c2l = 4;

3721

break;

3722

case INTERSECT_QUAD_LINE_NO:

3723

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;

3728

break;

3729

case INTERSECT_QUAD_2:

3730

f.push(7, 8, 0, 12);

3731

f.push(10, 11, 9, 19);

3732

c1s = 1; c1l = 6; c2s = 13; c2l = 6;

3733

break;

3734

case INTERSECT_QUAD_NO:

3735

c1s = 0; c1l = 6; c2s = 6; c2l = 6;

3736

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3737

case INTERSECT_CONIC_LINE:

3738

f.push(8, 9, 0, 10);

3739

c1s = 1; c1l = 7; c2s = 11; c2l = 4;

3740

break;

3741

case INTERSECT_CONIC_LINE_2:

3742

f.push(8, 9, 0, 12);

3743

f.push(11, 12, 10, 18);

3744

c1s = 1; c1l = 7; c2s = 14; c2l = 4;

3745

break;

3746

case INTERSECT_CONIC_LINE_NO:

3747

c1s = 0; c1l = 7; c2s = 7; c2l = 4;

3748

break;

3749

case INTERSECT_CONIC:

3750

f.push(8, 9, 0, 10);

3751

c1s = 1; c1l = 7; c2s = 11; c2l = 7;

3752

break;

3753

case INTERSECT_CONIC_2:

3754

f.push(8, 9, 0, 13);

3755

f.push(11, 12, 10, 21);

3756

c1s = 1; c1l = 7; c2s = 14; c2l = 7;

3757

break;

3758

case INTERSECT_CONIC_NO:

3759

c1s = 0; c1l = 7; c2s = 7; c2l = 7;

3760

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3761

case INTERSECT_SELF_CUBIC:

3762

f.push(9, 10, 0, 11);

3763

c1s = 1; c1l = 8; c2s = 0; c2l = 0;

3764

break;

3765

case INTERSECT_SELF_CUBIC_NO:

3766

c1s = 0; c1l = 8; c2s = 0; c2l = 0;

3767

break;

3768

case INTERSECT_CUBIC_LINE:

3769

f.push(9, 10, 0, 11);

3770

c1s = 1; c1l = 8; c2s = 12; c2l = 4;

3771

break;

3772

case INTERSECT_CUBIC_LINE_2:

3773

f.push(9, 10, 0, 14);

3774

f.push(12, 13, 11, 19);

3775

c1s = 1; c1l = 8; c2s = 15; c2l = 4;

3776

break;

3777

case INTERSECT_CUBIC_LINE_3:

3778

f.push(9, 10, 0, 17);

3779

f.push(12, 13, 11, 22);

3780

f.push(15, 16, 14, 23);

3781

c1s = 1; c1l = 8; c2s = 18; c2l = 4;

3782

break;

3783

case INTERSECT_CUBIC_QUAD_NO:

3784

c1s = 0; c1l = 8; c2s = 8; c2l = 6;

3785

break;

3786

case INTERSECT_CUBIC_QUAD:

3787

f.push(9, 10, 0, 11);

3788

c1s = 1; c1l = 8; c2s = 12; c2l = 6;

3789

break;

3790

case INTERSECT_CUBIC_QUAD_2:

3791

f.push(9, 10, 0, 14);

3792

f.push(12, 13, 11, 21);

3793

c1s = 1; c1l = 8; c2s = 15; c2l = 6;

3794

break;

3795

case INTERSECT_CUBIC_QUAD_3:

3796

f.push(9, 10, 0, 17);

3797

f.push(12, 13, 11, 24);

3798

f.push(15, 16, 14, 25);

3799

c1s = 1; c1l = 8; c2s = 18; c2l = 6;

3800

break;

3801

case INTERSECT_CUBIC_QUAD_4:

3802

f.push(9, 10, 0, 20);

3803

f.push(12, 13, 11, 27);

3804

f.push(15, 16, 14, 28);

3805

f.push(18, 19, 17, 29);

3806

c1s = 1; c1l = 8; c2s = 21; c2l = 6;

3807

break;

3808

case INTERSECT_CUBIC_LINE_NO:

3809

c1s = 0; c1l = 8; c2s = 8; c2l = 4;

3810

break;

3811

case INTERSECT_CUBIC:

3812

f.push(9, 10, 0, 11);

3813

c1s = 1; c1l = 8; c2s = 12; c2l = 8;

3814

break;

3815

case INTERSECT_CUBIC_2:

3816

f.push(9, 10, 0, 14);

3817

f.push(12, 13, 11, 23);

3818

c1s = 1; c1l = 8; c2s = 15; c2l = 8;

3819

break;

3820

case INTERSECT_CUBIC_3:

3821

f.push(9, 10, 0, 17);

3822

f.push(12, 13, 11, 26);

3823

f.push(15, 16, 14, 27);

3824

c1s = 1; c1l = 8; c2s = 18; c2l = 8;

3825

break;

3826

case INTERSECT_CUBIC_4:

3827

f.push(9, 10, 0, 20);

3828

f.push(12, 13, 11, 29);

3829

f.push(15, 16, 14, 30);

3830

f.push(18, 19, 17, 31);

3831

c1s = 1; c1l = 8; c2s = 21; c2l = 8;

3832

break;

3833

case INTERSECT_CUBIC_NO:

3834

c1s = 0; c1l = 8; c2s = 8; c2l = 8;

3835

break;

3836

default:

3837

console.log("unknown REC_TYPE_SECT frag type: " + fragType);

3838

throw "stop execution";

3839

}

3840

if (draw_intersection != 1) {

var id = -1;

var curve;

switch (c1l) {

case 4:

drawLine(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3]);

3846

if (draw_id) {

3847

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3]];

3848

id = idByCurve(test, curve, PATH_LINE);

}

break;

case 6:

drawQuad(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3853

frags[c1s + 4], frags[c1s + 5]);

3854

if (draw_id) {

3855

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3856

frags[c1s + 4], frags[c1s + 5]];

3857

id = idByCurve(test, curve, PATH_QUAD);

3858

}

3859

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3860

case 7:

3861

drawConicWithQuads(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3862

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6]);

3863

if (draw_id) {

3864

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3865

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6]];

3866

id = idByCurve(test, curve, PATH_CONIC);

3867

}

3868

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3869

case 8:

3870

drawCubic(frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3871

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6], frags[c1s + 7]);

3872

if (draw_id) {

3873

curve = [frags[c1s], frags[c1s + 1], frags[c1s + 2], frags[c1s + 3],

3874

frags[c1s + 4], frags[c1s + 5], frags[c1s + 6], frags[c1s + 7]];

3875

id = idByCurve(test, curve, PATH_CUBIC);

}

break;

}

if (id >= 0) {

drawID(curve, id);

}

id = -1;

switch (c2l) {

case 0:

break;

case 4:

drawLine(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3]);

3888

if (draw_id) {

3889

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3]];

3890

id = idByCurve(test, curve, PATH_LINE);

}

break;

case 6:

drawQuad(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3895

frags[c2s + 4], frags[c2s + 5]);

3896

if (draw_id) {

3897

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3898

frags[c2s + 4], frags[c2s + 5]];

3899

id = idByCurve(test, curve, PATH_QUAD);

3900

}

3901

break;

caryclark

2015-04-20 08:31:59 -0700

[diff] [blame]

3902

case 7:

3903

drawConicWithQuads(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3904

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6]);

3905

if (draw_id) {

3906

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3907

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6]];

3908

id = idByCurve(test, curve, PATH_CONIC);

3909

}

3910

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3911

case 8:

3912

drawCubic(frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3913

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6], frags[c2s + 7]);

3914

if (draw_id) {

3915

curve = [frags[c2s], frags[c2s + 1], frags[c2s + 2], frags[c2s + 3],

3916

frags[c2s + 4], frags[c2s + 5], frags[c2s + 6], frags[c2s + 7]];

3917

id = idByCurve(test, curve, PATH_CUBIC);

}

break;

}

if (id >= 0) {

drawID(curve, id);

}

}

if (collect_bounds) {

3926

break;

3927

}

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3928

if (draw_intersection != 3 || step_limit == 0 || tIndex >= lastSect) {

3929

for (var idx = 0; idx < f.length; idx += 4) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3930

drawPoint(frags[f[idx]], frags[f[idx + 1]], true);

3931

}

3932

}

3933

if (!draw_intersectT) {

3934

break;

3935

}

3936

ctx.fillStyle = "red";

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

3937

if (draw_intersection != 3 || step_limit == 0 || tIndex >= lastSect) {

3938

for (var idx = 0; idx < f.length; idx += 4) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3939

drawTAtPointUp(frags[f[idx]], frags[f[idx + 1]], frags[f[idx + 2]]);

3940

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)";

3950

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);

3959

throw "stop execution";

3960

}

3961

break;

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

3962

case REC_TYPE_TOP:

3963

if (!draw_top || (step_limit > 0 && tIndex < lastTop)) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = "rgba(127,127,0, 0.5)";

3968

focus_enabled = true;

3969

{

3970

var curve = curvePartialByID(test, frags[0], frags[1], frags[2]);

3971

drawCurve(curve);

3972

var type = PATH_LINE + (curve.length / 2 - 2);

3973

var mid = pointAtT(curve, type, 0.5);

3974

var d = dxy_at_t(curve, type, 0.5);

3975

drawArrow(mid.x, mid.y, d.x, d.y, 0.3);

3976

}

3977

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

3978

case REC_TYPE_MARK:

3979

if (!draw_mark || (step_limit > 0 && tIndex < lastMark)) {

continue;

}

ctx.lineWidth = 3;

ctx.strokeStyle = fragType >= MARK_DONE_LINE ?

3984

"rgba(127,0,127, 0.5)" : "rgba(127,127,0, 0.5)";

3985

focus_enabled = true;

switch (fragType) {

case MARK_LINE:

case MARK_DONE_LINE:

case MARK_UNSORTABLE_LINE:

3990

case MARK_SIMPLE_LINE:

3991

case MARK_SIMPLE_DONE_LINE:

3992

case MARK_DONE_UNARY_LINE:

3993

drawLinePartial(frags[1], frags[2], frags[3], frags[4],

3994

frags[5], frags[9]);

3995

if (draw_id) {

3996

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:

4003

case MARK_SIMPLE_QUAD:

4004

case MARK_SIMPLE_DONE_QUAD:

4005

case MARK_DONE_UNARY_QUAD:

4006

drawQuadPartial(frags[1], frags[2], frags[3], frags[4],

4007

frags[5], frags[6], frags[7], frags[11]);

4008

if (draw_id) {

4009

drawQuadPartialID(frags[0], frags[1], frags[2], frags[3], frags[4],

4010

frags[5], frags[6], frags[7], frags[11]);

}

break;

case MARK_CUBIC:

case MARK_DONE_CUBIC:

4015

case MARK_UNSORTABLE_CUBIC:

4016

case MARK_SIMPLE_CUBIC:

4017

case MARK_SIMPLE_DONE_CUBIC:

4018

case MARK_DONE_UNARY_CUBIC:

4019

drawCubicPartial(frags[1], frags[2], frags[3], frags[4],

4020

frags[5], frags[6], frags[7], frags[8], frags[9], frags[13]);

4021

if (draw_id) {

4022

drawCubicPartialID(frags[0], frags[1], frags[2], frags[3], frags[4],

4023

frags[5], frags[6], frags[7], frags[8], frags[9], frags[13]);

4024

}

4025

break;

4026

case MARK_ANGLE_LAST:

4027

// FIXME: ignored for now

4028

break;

4029

default:

4030

console.log("unknown REC_TYPE_MARK frag type: " + fragType);

4031

throw "stop execution";

}

break;

default:

continue;

}

}

switch (recType) {

case REC_TYPE_SORT:

if (!draw_sort || (step_limit > 0 && tIndex < lastSort)) {

4041

break;

4042

}

4043

var angles = []; // use tangent lines to describe arcs

var windFrom = [];

var windTo = [];

var opp = [];

var minXY = Number.MAX_VALUE;

4048

var partial;

4049

focus_enabled = true;

4050

var someUnsortable = false;

4051

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

4052

var fragType = records[recordIndex];

4053

var frags = records[recordIndex + 1];

4054

var unsortable = (fragType == SORT_UNARY && frags[14]) ||

4055

(fragType == SORT_BINARY && frags[16]);

4056

someUnsortable |= unsortable;

switch (fragType) {

case SORT_UNARY:

case SORT_BINARY:

partial = curvePartialByID(test, frags[0], frags[6], frags[8]);

4061

break;

4062

default:

4063

console.log("unknown REC_TYPE_SORT frag type: " + fragType);

4064

throw "stop execution";

4065

}

4066

var dx = boundsWidth(partial);

4067

var dy = boundsHeight(partial);

4068

minXY = Math.min(minXY, dx * dx + dy * dy);

4069

if (collect_bounds) {

4070

continue;

4071

}

4072

angles.push(tangent(partial));

4073

var from = frags[12];

var to = frags[12];

var sgn = frags[10];

if (sgn < 0) {

from -= frags[11];

} else if (sgn > 0) {

4079

to -= frags[11];

4080

}

4081

windFrom.push(from + (unsortable ? "!" : ""));

4082

windTo.push(to + (unsortable ? "!" : ""));

4083

opp.push(fragType == SORT_BINARY);

4084

if (draw_sort == 1) {

4085

drawOrder(partial, frags[12]);

4086

} else {

4087

drawOrder(partial, (recordIndex / 2) + 1);

4088

}

4089

}

4090

var radius = Math.sqrt(minXY) / 2 * scale;

4091

radius = Math.min(50, radius);

4092

var scaledRadius = radius / scale;

4093

var centerX = partial[0];

4094

var centerY = partial[1];

4095

if (collect_bounds) {

4096

if (focus_enabled) {

4097

focusXmin = Math.min(focusXmin, centerX - scaledRadius);

4098

focusYmin = Math.min(focusYmin, centerY - scaledRadius);

4099

focusXmax = Math.max(focusXmax, centerX + scaledRadius);

4100

focusYmax = Math.max(focusYmax, centerY + scaledRadius);

}

break;

}

break;

default:

break;

}

}

if (collect_bounds) {

4110

return;

4111

}

4112

if (draw_log && logStart >= 0) {

4113

ctx.font = "normal 10px Arial";

4114

ctx.textAlign = "left";

4115

ctx.beginPath();

4116

var top = screenHeight - 20 - (logRange + 2) * 10;

4117

ctx.rect(50, top, screenWidth - 100, (logRange + 2) * 10);

4118

ctx.fillStyle = "white";

4119

ctx.fill();

4120

ctx.fillStyle = "rgba(0,0,0, 0.5)";

4121

if (logStart > 0) {

4122

ctx.fillText(lines[logStart - 1], 50, top + 8);

4123

}

4124

ctx.fillStyle = "black";

4125

for (var idx = 0; idx < logRange; ++idx) {

4126

ctx.fillText(lines[logStart + idx], 50, top + 18 + 10 * idx);

4127

}

4128

ctx.fillStyle = "rgba(0,0,0, 0.5)";

4129

if (logStart + logRange < lines.length) {

4130

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]

4135

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4136

// drawBox(pos++, "yellow", "black", opLetter, true, '');

4137

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_intersection > 1 ? sectCount : sectMax2, draw_intersection, intersectionKey);

4138

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_add ? addCount : addMax, draw_add, addKey);

4139

drawBox(pos++, "rgba(0,0,255, 0.3)", "black", draw_active ? activeCount : activeMax, draw_active, activeKey);

4140

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]

4141

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]

4142

drawBox(pos++, "rgba(127,127,0, 0.3)", "black", draw_op ? opCount : opMax, draw_op, opKey);

4143

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]

4144

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]

4145

drawBox(pos++, "rgba(127,0,127, 0.3)", "black", draw_mark ? markCount : markMax, draw_mark, markKey);

4146

drawBox(pos++, "black", "white",

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

4147

(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]

4148

drawBox(pos++, "rgba(0,63,0, 0.7)", "white",

4149

(new Array('Q', 'Q', 'C', 'QC', 'Qc', 'Cq'))[draw_computed],

4150

draw_computed != 0, computedKey);

4151

drawBox(pos++, "green", "black", step_limit, drawSomething, '');

4152

drawBox(pos++, "green", "black", stepMax, drawSomething, '');

4153

drawBox(pos++, "rgba(255,0,0, 0.6)", "black", lastIndex, drawSomething & draw_log, '');

4154

drawBox(pos++, "rgba(255,0,0, 0.6)", "black", test.length - 1, drawSomething & draw_log, '');

if (curve_t) {

drawCurveTControl();

}

ctx.font = "normal 20px Arial";

4159

ctx.fillStyle = "rgba(0,0,0, 0.3)";

4160

ctx.textAlign = "right";

4161

ctx.fillText(scale.toFixed(decimal_places) + 'x' , screenWidth - 10, screenHeight - 5);

4162

}

4163

if (draw_hints) {

4164

ctx.font = "normal 10px Arial";

4165

ctx.fillStyle = "rgba(0,0,0, 0.5)";

4166

ctx.textAlign = "right";

4167

var y = 4;

4168

ctx.fillText("control lines : " + controlLinesKey, ctx.screenWidthwidth - 10, pos * 50 + y++ * 10);

4169

ctx.fillText("curve t : " + curveTKey, screenWidth - 10, pos * 50 + y++ * 10);

4170

ctx.fillText("deriviatives : " + deriviativesKey, screenWidth - 10, pos * 50 + y++ * 10);

4171

ctx.fillText("intersect t : " + intersectTKey, screenWidth - 10, pos * 50 + y++ * 10);

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4172

ctx.fillText("log : " + logKey, screenWidth - 10, pos * 50 + y++ * 10);

4173

ctx.fillText("log curve : " + logCurvesKey, screenWidth - 10, pos * 50 + y++ * 10);

4174

ctx.fillText("mid point : " + midpointKey, screenWidth - 10, pos * 50 + y++ * 10);

4175

ctx.fillText("points : " + ptsKey, screenWidth - 10, pos * 50 + y++ * 10);

4176

ctx.fillText("sequence : " + sequenceKey, screenWidth - 10, pos * 50 + y++ * 10);

4177

ctx.fillText("xy : " + xyKey, screenWidth - 10, pos * 50 + y++ * 10);

}

}

function drawBox(y, backC, foreC, str, enable, label) {

4182

ctx.beginPath();

4183

ctx.fillStyle = backC;

4184

ctx.rect(screenWidth - 40, y * 50 + 10, 40, 30);

4185

ctx.fill();

4186

ctx.font = "normal 16px Arial";

4187

ctx.fillStyle = foreC;

4188

ctx.textAlign = "center";

4189

ctx.fillText(str, screenWidth - 20, y * 50 + 32);

4190

if (!enable) {

4191

ctx.fillStyle = "rgba(255,255,255, 0.5)";

ctx.fill();

}

if (label != '') {

ctx.font = "normal 9px Arial";

4196

ctx.fillStyle = "black";

4197

ctx.fillText(label, screenWidth - 47, y * 50 + 40);

}

}

function drawCurveTControl() {

4202

ctx.lineWidth = 2;

4203

ctx.strokeStyle = "rgba(0,0,0, 0.3)";

4204

ctx.beginPath();

4205

ctx.rect(screenWidth - 80, 40, 28, screenHeight - 80);

4206

ctx.stroke();

4207

var ty = 40 + curveT * (screenHeight - 80);

4208

ctx.beginPath();

4209

ctx.moveTo(screenWidth - 80, ty);

4210

ctx.lineTo(screenWidth - 85, ty - 5);

4211

ctx.lineTo(screenWidth - 85, ty + 5);

4212

ctx.lineTo(screenWidth - 80, ty);

4213

ctx.fillStyle = "rgba(0,0,0, 0.6)";

4214

ctx.fill();

4215

var num = curveT.toFixed(decimal_places);

4216

ctx.font = "normal 10px Arial";

4217

ctx.textAlign = "left";

4218

ctx.fillText(num, screenWidth - 78, ty);

4219

}

4220

4221

function ptInTControl() {

4222

var e = window.event;

4223

var tgt = e.target || e.srcElement;

4224

var left = tgt.offsetLeft;

4225

var top = tgt.offsetTop;

4226

var x = (e.clientX - left);

4227

var y = (e.clientY - top);

4228

if (x < screenWidth - 80 || x > screenWidth - 50) {

4229

return false;

4230

}

4231

if (y < 40 || y > screenHeight - 80) {

4232

return false;

4233

}

4234

curveT = (y - 40) / (screenHeight - 120);

4235

if (curveT < 0 || curveT > 1) {

4236

throw "stop execution";

}

return true;

}

function drawTop() {

if (tests[testIndex] == null) {

4243

var str = testDivs[testIndex].textContent;

4244

parse_all(str);

4245

var title = testDivs[testIndex].id.toString();

4246

testTitles[testIndex] = title;

4247

}

4248

init(tests[testIndex]);

redraw();

}

function redraw() {

if (focus_on_selection) {

4254

collect_bounds = true;

4255

draw(tests[testIndex], testLines[testIndex], testTitles[testIndex]);

4256

collect_bounds = false;

4257

if (focusXmin < focusXmax && focusYmin < focusYmax) {

4258

setScale(focusXmin, focusXmax, focusYmin, focusYmax);

}

}

ctx.beginPath();

ctx.fillStyle = "white";

4263

ctx.rect(0, 0, screenWidth, screenHeight);

4264

ctx.fill();

4265

draw(tests[testIndex], testLines[testIndex], testTitles[testIndex]);

4266

}

4267

4268

function dumpCurvePartial(test, id, t0, t1) {

4269

var curve = curveByID(test, id);

4270

var name = ["line", "quad", "cubic"][curve.length / 2 - 2];

4271

console.log("id=" + id + " " + name + "=" + curveToString(curve)

4272

+ " t0=" + t0 + " t1=" + t1

4273

+ " partial=" + curveToString(curvePartialByID(test, id, t0, t1)));

4274

}

4275

4276

function dumpAngleTest(test, id, t0, t1) {

4277

var curve = curveByID(test, id);

4278

console.log(" { {" + curveToString(curve) + "}, "

4279

+ curve.length / 2 + ", " + t0 + ", " + t1 + ", {} }, //");

4280

}

4281

4282

function dumpLogToConsole() {

if (logStart < 0) {

return;

}

var test = tests[testIndex];

4287

var recType = REC_TYPE_UNKNOWN;

4288

var records;

4289

for (var index = 0; index < test.length; index += 3) {

4290

var lastLineNo = test[index + 1];

4291

if (lastLineNo >= logStart && lastLineNo < logStart + logRange) {

4292

recType = test[index];

4293

records = test[index + 2];

break;

}

}

if (recType == REC_TYPE_UNKNOWN) {

4298

return;

4299

}

4300

var lines = testLines[testIndex];

4301

for (var idx = 0; idx < logRange; ++idx) {

4302

var line = lines[logStart + idx];

4303

console.log(line);

4304

for (var recordIndex = 0; recordIndex < records.length; recordIndex += 2) {

4305

var fragType = records[recordIndex];

4306

var frags = records[recordIndex + 1];

4307

if (recType == REC_TYPE_ANGLE && fragType == ANGLE_AFTER) {

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4308

dumpCurvePartial(test, frags[0], frags[4], frags[5]);

4309

dumpCurvePartial(test, frags[6], frags[10], frags[11]);

4310

dumpCurvePartial(test, frags[12], frags[16], frags[17]);

4311

console.log("\nstatic IntersectData intersectDataSet[] = { //");

4312

dumpAngleTest(test, frags[0], frags[4], frags[5]);

4313

dumpAngleTest(test, frags[6], frags[10], frags[11]);

4314

dumpAngleTest(test, frags[12], frags[16], frags[17]);

4315

console.log("}; //");

}

}

}

}

var activeKey = 'a';

var pathKey = 'b';

var pathBackKey = 'B';

4324

var centerKey = 'c';

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

4325

var coincidenceKey = 'C';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4326

var addKey = 'd';

4327

var deriviativesKey = 'f';

4328

var angleKey = 'g';

4329

var angleBackKey = 'G';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4330

var intersectionKey = 'i';

4331

var intersectionBackKey = 'I';

4332

var sequenceKey = 'j';

4333

var midpointKey = 'k';

4334

var logKey = 'l';

4335

var logToConsoleKey = 'L';

var markKey = 'm';

var sortKey = 'o';

var opKey = 'p';

var opBackKey = 'P';

var computedKey = 'q';

4341

var computedBackKey = 'Q';

4342

var stepKey = 's';

4343

var stepBackKey = 'S';

4344

var intersectTKey = 't';

caryclark

2015-04-23 09:13:37 -0700

[diff] [blame]

4345

var topKey = 'T';

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4346

var curveTKey = 'u';

4347

var controlLinesBackKey = 'V';

4348

var controlLinesKey = 'v';

4349

var ptsKey = 'x';

4350

var xyKey = 'y';

4351

var logCurvesKey = 'z';

4352

var focusKey = '`';

4353

var idKey = '.';

4354

var retinaKey = '\\';

4355

4356

function doKeyPress(evt) {

4357

var char = String.fromCharCode(evt.charCode);

4358

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;

redraw();

break;

case addKey:

draw_add ^= true;

redraw();

break;

case angleKey:

caryclark

2015-03-26 07:52:43 -0700

[diff] [blame]

4382

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);

4391

redraw();

4392

break;

caryclark

2015-05-11 07:21:27 -0700

[diff] [blame]

4393

case coincidenceKey:

4394

draw_coincidence ^= true;

4395

redraw();

4396

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4397

case controlLinesBackKey:

4398

control_lines = (control_lines + 3) % 4;

4399

redraw();

4400

break;

4401

case controlLinesKey:

4402

control_lines = (control_lines + 1) % 4;

4403

redraw();

4404

break;

4405

case computedBackKey:

4406

draw_computed = (draw_computed + 5) % 6;

redraw();

break;

case computedKey:

draw_computed = (draw_computed + 1) % 6;

redraw();

break;

case curveTKey:

curve_t ^= true;

if (curve_t) {

draw_legend = true;

}

redraw();

break;

case deriviativesKey:

4421

draw_deriviatives = (draw_deriviatives + 1) % 3;

redraw();

break;

case focusKey:

focus_on_selection ^= true;

4426

setScale(xmin, xmax, ymin, ymax);

4427

redraw();

4428

break;

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

case idKey:

draw_id ^= true;

redraw();

break;

case intersectionBackKey:

4434

draw_intersection = (draw_intersection + 3) % 4;

4435

redraw();

4436

break;

4437

case intersectionKey:

4438

draw_intersection = (draw_intersection + 1) % 4;

redraw();

break;

case intersectTKey:

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;

4471

redraw();

4472

break;

4473

case pathKey:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

4474

draw_path = (draw_path + 1) % (4 + (hasAlignedPath ? 3 : 0));

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

4475

redraw();

4476

break;

4477

case pathBackKey:

caryclark

2015-10-16 09:03:38 -0700

[diff] [blame]

4478

draw_path = (draw_path + 3 + (hasAlignedPath ? 3 : 0)) % (4 + (hasAlignedPath ? 3 : 0));

caryclark

2014-06-17 05:15:38 -0700

[diff] [blame]

redraw();

break;

case ptsKey:

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) {

4500

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