static const char * parse( const char *start, const char *finish, std::vector< event> &events ) { // alternatives, // 1) glob until '7777' (will not work because 7777 could appear in body as well as end) // 2) glob until end_of_gts_bulletin (will not work because may have more than one grib in bulletin) // 3) rely on the encoded grib size instead (use this approach). typedef chseq_< 'G', 'R', 'I', 'B'> grib_header; start = grib_header::parse( start, finish, events ); if( !start ) return 0; // may not be correct for grib2 - need to check edition as well. // we need at least 3 chars, to pick out grib len, note, finish is one past end. if( !( finish - start > 5)) return 0; int len = dec3( (unsigned char *)start ); start += len - 8; // we have to do this, because many parsing constructs only check // parse == finish for termination if( start >= finish ) return 0; typedef chseq_< '7', '7', '7', '7'> grib_footer; start = grib_footer::parse( start, finish, events ); return start; }
void ut_class_test(void) { al::AudioIO io(64, 44100, 0, 0, 2, 2, al::AudioIO::DUMMY); // Dummy Audio Backend al::Decorrelation dec(32, 1, 1, false); dec.configure(io, 1000); assert(dec.getCurrentSeed() == 1000); assert(dec.getSize() == 32); float *ir = dec.getIR(0); double expected[] = {0.65027274, -0.16738815, 0.1617437 , 0.18901241, 0.01768662, -0.0802799 , -0.12612745, 0.09564361, 0.00803435, 0.07643685, -0.030273 , 0.26991193, -0.03412993, -0.05709789, 0.05474607, -0.12850219, 0.03040506, -0.05887395, 0.05779415, 0.12589107, 0.0778308 , -0.19303948, 0.16970104, -0.34332016, -0.14030879, 0.02862106, 0.18978155, 0.02629568, -0.09265464, -0.04808504, 0.00549774, 0.26477413}; for (int i = 0; i < 32; i++) { // std::cout << ir[i] << "..." << expected[i]; assert(fabs(ir[i] - expected[i]) < 0.000001); } std::cout << std::endl; al::Decorrelation dec2(1024, 1, 32, false); dec2.configure(io, 1001); assert(dec2.getCurrentSeed() == 1001); assert(dec2.getSize() == 1024); al::Decorrelation dec3(10, 1, 8, false); dec3.configure(io, 1001); assert(dec3.getCurrentSeed() == 1001); assert(dec3.getSize() == 0); // Size of 10 is too small al::Decorrelation dec4(32, 1, 0); dec4.configure(io, 1001); assert(dec4.getSize() == 0); // Num Outs is 0 }
int main() { char d = 'r'; // Intialise restart variable to 'r' so the program runs on launch. do { if (d == 'r' || d == 'R') { char d = 'x'; // Set the restart variable back to 'x' to stop further loops. //============================================================= // // SET ARRAY TO 0 // //============================================================= int i, j, z; // Setting all the values of the array i = Y axis j = X axis z = Colour type (RGB). for (i = 0; i < height; i++) { for (j = 0; j < width; j++) { for (z = 0; z < 3; z++) { numbers[i][j][z] = 0; // Sets the whole array to 0. } } } //============================================================= // // DRAW AXIS LINES // //============================================================= /*Set Y Axis Line*/ { int y, w; // y = y axis level, w = axis line width. for (y = 8; y < 109; y++) { for (w = 37; w < 39; w++) { numbers[y][w][0] = 255; numbers[y][w][1] = 255; numbers[y][w][2] = 255; } } } /*Set X Axis Line*/ { int x, w; // x = x axis level, w = axis line width. for (x = 37; x < 219; x++) { for (w = 109; w < 111; w++) { numbers[w][x][0] = 255; numbers[w][x][1] = 255; numbers[w][x][2] = 255; } } } /*Set X Axis Centre Line*/ { int x; // x = x axis level. for (x = 39; x < 219; x++) { numbers[58][x][0] = 168; numbers[58][x][1] = 177; numbers[58][x][2] = 181; } } //============================================================= // // DRAW AXIS TICKS // //============================================================= /*Y Axis Ticks*/ { int x, c; for (x = 35; x < 37; x++) { for (c = 0; c < 3; c++) { numbers[19][x][c] = 255; // '1.0' Value Tick numbers[58][x][c] = 255; // '0.0' value Tick numbers[97][x][c] = 255; // '-1.0' value Tick } } } /*X Axis Ticks */ { int y, c; for (y = 111; y < 113; y++) { for (c = 0; c < 3; c++) { numbers[y][39][c] = 255; // '0 deg' value Tick numbers[y][83][c] = 255; // '180 deg' value Tick numbers[y][128][c] = 255; // '360 deg' value Tick numbers[y][173][c] = 255; // '540 deg' value Tick numbers[y][218][c] = 255; // '720 deg' value Tick } } } //============================================================= // // Y AXIS NUMBERS // //============================================================= ones(17, 26); // decs(21, 28); // "1.0" zero(17, 30); // zero(56, 24); // decs(59, 28); // "0.0" zero(56, 30); // dec2(97, 23); // ones(95, 26); // "-1.0" decs(99, 28); // zero(95, 30); // //============================================================= // // X AXIS NUMBERS // //============================================================= zero(114, 38); // "0" zero(114, 82); // zero(114, 86); // "180" ones(114, 80); // decs(116, 83); // dec2(114, 123); // dec2(116, 123); // dec2(118, 123); // zero(114, 131); // dec2(116, 128); // "360" dec2(118, 128); // decs(117, 129); // ones(114, 125); // ones(114, 127); // zero(114, 176); // dec2(114, 168); // dec3(114, 167); // decs(116, 168); // dec3(116, 169); // "540" dec2(118, 167); // dec3(114, 171); // dec2(117, 171); // dec3(116, 173); // decs(117, 174); // ones(114, 215); // zero(114, 221); // dec2(114, 213); // dec2(114, 217); // decs(114, 219); // "720" decs(115, 219); // decs(116, 218); // decs(117, 217); // dec2(118, 217); // decs(118, 219); // //============================================================= // // WAVEFORMS // //============================================================= int inp, r1[999], g1[999], b1[999]; // Previous waveform colour save arrays. { int t = 0; int offt, offs, ap, j, z, c, r, g, b; double val; ap = 40; // Amplitude. val = PI / 180; // Radians to degrees conversion. offt = 39; // Offset in the x direction. offs = 58; // Offset in the y direction. int count = 1; printf("How many sine waves of accuracy do you want? "); scanf("%d/n", &inp); time_t e; // Define colour generator. srand((unsigned)time(&e)); // while (inp <= 0 || inp > 999) // Accuracy must be between 1 and 999 { printf("\nNumber must be between 1 and 999! Try again. "); scanf("%d/n", &inp); } if (inp > 500) { printf("\nYikes! This might take a while..."); } else { printf("Please Wait..."); } // BUILD PREVIOUS SINE WAVEFORMS { for (c = inp; c > 0; c--) { int s = 0; j = ((2 * c) - 1); for (t = 0; t < 720; t++) { s = 0; for (count = 1; count <= j; count += 2) { s = (int)((ap / count) * (sin(count*t*val))); // Generate Equation for next waveform. } z = offs - s; numbers[z][offt + (t / 4)][0] = 150; // numbers[z][offt + (t / 4)][1] = 0; // Colour is always dark red for each waveform. numbers[z][offt + (t / 4)][2] = 0; // } } } // BUILD PREVIOUS SQUARE WAVEFORMS { for (c = inp; c > 0; c--) { r = (rand() % 150) + 50; // g = (rand() % 150) + 50; // Create random colour between 50 & 200 for each waveform. b = (rand() % 150) + 50; // r1[c] = r; // g1[c] = g; // Stores colour for each wave to fetch later... b1[c] = b; // int s = 0; j = ((2 * c) - 1); for (t = 0; t < 720; t++) { s = 0; for (count = 1; count <= j; count += 2) { s = (int)(((ap / count) * (sin(count*t*val))) + s); // Generate Equation for next waveform. } z = offs - s; numbers[z][offt + (t / 4)][0] = r; // numbers[z][offt + (t / 4)][1] = g; // Random colour for each waveform. numbers[z][offt + (t / 4)][2] = b; // } } } // BUILD FINAL SQAURE WAVEFORM int s = 0; j = ((2 * inp) - 1); for (t = 0; t < 720; t++) { s = 0; for (count = 1; count <= j; count += 2) { s = (int)(((ap / count) * (sin(count*t*val))) + s); // Generate Equation for next waveform. } z = offs - s; numbers[z][offt + (t / 4)][0] = 245; // numbers[z][offt + (t / 4)][1] = 245; // Final waveform is always yellow. numbers[z][offt + (t / 4)][2] = 60; // } } //============================================================= // // WAVEFORM KEY // //============================================================= { int c; // Line pixel counter. /* "FIRST" */ dec2(13, 218); // ones(13, 217); // "F" dec2(15, 218); // ones(13, 221); // "I" ones(13, 223); // dec2(13, 224); // decs(14, 225); // "R" dec2(15, 224); // decs(16, 224); // decs(17, 225); // dec2(13, 227); // decs(13, 229); // decs(14, 227); // decs(15, 228); // "S" decs(16, 229); // dec2(17, 227); // decs(17, 229); // dec2(13, 231); // decs(13, 233); // "T" dec3(14, 232); // decs(17, 232); // /* First "=" */ dec2(14, 235); decs(14, 237); dec2(16, 235); decs(16, 237); /* "FINAL" */ if (inp > 1) { ones(23, 216); // dec2(23, 217); // "F" dec2(25, 217); // ones(23, 220); // "I" ones(23, 222); // decs(24, 223); // decs(25, 223); // "N" decs(25, 224); // decs(26, 224); // ones(23, 225); // dec3(24, 227); // decs(27, 227); // decs(23, 228); // "A" decs(25, 228); // dec3(24, 229); // decs(27, 229); // ones(23, 231); // "L" dec2(27, 232); // /*Final "="*/ dec2(24, 235); decs(24, 237); dec2(26, 235); decs(26, 237); /*Final Sample Line*/ for (c = 0; c < 15; c++) { numbers[25][239 + c][0] = 245; // numbers[25][239 + c][1] = 245; // Line sample of the final waveform. This is always yellow. numbers[25][239 + c][2] = 60; // } /*First Sample Line*/ for (c = 0; c < 15; c++) { numbers[15][239 + c][0] = r1[1]; // numbers[15][239 + c][1] = g1[1]; // Line sample of the first waveform if > 1 has been displayed. numbers[15][239 + c][2] = b1[1]; // } c = 0; } else { /*First Sample Line*/ for (c = 0; c < 15; c++) { numbers[15][239 + c][0] = 245; // numbers[15][239 + c][1] = 245; // Line sample of the first waveform if only 1 has been displayed. numbers[15][239 + c][2] = 60; // } c = 0; } /* "KEY" */ ones(3, 226); // decs(5, 227); // decs(4, 228); // "K" decs(3, 229); // decs(6, 228); // decs(7, 229); // ones(3, 231); // dec2(3, 232); // "E" dec2(5, 232); // dec2(7, 232); // decs(3, 235); // decs(4, 235); // dec3(5, 236); // "Y" decs(3, 237); // decs(4, 237); // /* "KEY" Underline */ for (c = 224; c < 239; c++) { numbers[8][c][0] = 171; numbers[8][c][1] = 171; numbers[8][c][2] = 171; } c = 0; /* Outer Lines*/ for (c = 0; c < 31; c++) { numbers[c][210][0] = 230; // numbers[c][210][1] = 230; // Vertical "off-white" colour, key boundary line. numbers[c][210][2] = 230; // } c = 0; for (c = 210; c < 256; c++) { numbers[30][c][0] = 230; // numbers[30][c][1] = 230; // Horizontal "off-white" colour, key boundary line. numbers[30][c][2] = 230; // } c = 0; } //============================================================= // // OPEN AND SET PPM FILE HEADER // //============================================================= FILE *pfile = NULL; // Create file pointer and set to NULL. if ((pfile = fopen("myimage.ppm", "w")) == NULL) /* Checks if the .pmm file can be opened successfully. Returns -1 if there is a problem.*/ { printf("\nThere was a problem opening '%s', please contact support.", "myimage.ppm"); return -1; } fprintf(pfile, "P3\n"); // Identify PPM file type. fprintf(pfile, "# myimage.ppm\n"); // Writes confirmation comment of the file name. fprintf(pfile, "%d %d\n", width, height); // Writes the width and height of the array. fprintf(pfile, "%d\n", colour); // Writes the colour depth level (always 255). //============================================================= // // WRITE DATA FROM ARRAY TO FILE // //============================================================= int a, b, c; for (a = 0; a < height; a++) { for (b = 0; b < width; b++) { for (c = 0; c < 3; c++) { fprintf(pfile, "%d", numbers[a][b][c]); fprintf(pfile, " "); }fprintf(pfile, " "); }fprintf(pfile, "\n\n"); } // The file can be found here...\executable_folder\myimage.ppm printf("\nMade Changes! Look for 'myimage.pmm' in the project folder.\n\n"); fclose(pfile); } printf("Press [R] to restart or any key to exit...\n\n\n\n"); d = _getch(); } while (d == 'r' || d == 'R'); printf("\n\n"); printf("Goodbye! "); }