void INS_EDGE(CSG *csg, CSG_Node *source, CSG_Node *target) { CSG_Node **bucket; if (*(LABEL(target)) == LAST_SYMBOL) SET_FINAL(source); else { if (OUT(source) == 0) { source->arc = (CSG_Node **)target; } else { if (OUT(source) == 1) { bucket = (CSG_Node **)malloc(sizeof(CSG_Node *) * 2); bucket[0] = (CSG_Node *)source->arc; source->arc = bucket; } else if (OUT(source) == 2) { source->arc = (CSG_Node **)realloc(source->arc , sizeof(CSG_Node *) * 5); } source->arc[OUT(source)] = target; } OUT(source)++; LG(target) = MAX(LG(target), (IS_INITIAL(source) ? 0 : LG(source) + LEN_L(source))); } };
int GET_SOLID(CSG *csg, CSG_Node *source, CSG_Node *node_t) { int res = (LG(node_t) == (IS_INITIAL(source) ? 0 : LG(source) + LEN_L(source) )); return res; }
CSG_Node *divide(CSG *csg, CSG_Node *state, int lprefix, CSG_Node *target) { CSG_Node *waiting = target; int waiting_lprefix = LEN_L(state) - lprefix; int is_leaf = IS_LEAF(state); //int j; /* delete */ LEN_L(state) = lprefix; if (is_leaf) { /* the leaf is converted to a node and is created a new leaf */ DEC_NLEAFS; INC_NNODES; if (target == NINDEF || LABEL(target)!=(LABEL(state) + lprefix)) { INC_NLEAFS; waiting = insert_leaf(csg, LABEL(state) + lprefix, LINDEF); } } else { INC_NNODES; if (target == NINDEF) { waiting = insert_leaf(csg, LABEL(state) + lprefix, waiting_lprefix); } LG(waiting) = (IS_INITIAL(state) ? 0 : LG(state) + LEN_L(state)); waiting->arc = state->arc; OUT(waiting) = OUT(state); OUT(state) = 0; } INS_EDGE(csg, state, waiting); return waiting; }
CSG_Node *to_clone(CSG *csg, CSG_Node *state, CSG_Node *nextState) /* state: actual state; nextState: state to clone */ { CSG_Node *clon = INITIAL + ++csg->last_state; CSG_Node *candidat = state; CSG_Node *parent_state = state; int lprefix = LEN_L(state); const char *prefix = LABEL(nextState); int trobat = TRUE; uint lg_clon = (IS_INITIAL(state)? 0 : LG(state) + LEN_L(state)); if (!IS_LEAF(nextState)) { INC_NNODES; CLONE_EDGES(nextState, clon); } else { INC_NLEAFS; } LABEL(clon) = LABEL(nextState); LEN_L(clon) = LEN_L(nextState); CLINK(clon) = CLINK(nextState); CLINK(nextState) = clon; do { if (NEXT(csg, candidat, *prefix) == nextState) { SWAP_EDGE(csg, candidat, nextState, clon); } else { trobat = FALSE; } state = candidat; class_link(csg, &candidat, &parent_state, &lprefix); } while (trobat && candidat != state); LG(clon) = lg_clon; return clon; }
CSG_Node *compres_leaf(CSG *csg, CSG_Node *source, CSG_Node *parent_state , CSG_Node *state, CSG_Node *waiting, int lprefix) { //const char *prefix = LABEL(state); LEN_L(source) = LEN_L(source) - lprefix; /* update actual state*/ LEN_L(state) = lprefix; /* clear old edge */ /* insert edge betwen the compress node and split node */ SWAP_EDGE(csg, source, waiting, state); LG(state) = (IS_INITIAL(source)? 0 : LG(source) + LEN_L(source)); /* insert waiting edge */ DEC_NLEAFS; INC_NNODES; INS_EDGE(csg, state, waiting); return state; }
int esweep_lg(esweep_object *obj) { /* logarithm to base 10 */ Wave *wave; Polar *polar; Surface *surface; Complex *cpx; int i, zsize; Real abs, arg; ESWEEP_OBJ_NOTEMPTY(obj, ERR_EMPTY_OBJECT); switch (obj->type) { case WAVE: wave=(Wave*) obj->data; for (i=0; i<obj->size; i++) { wave[i]=LG(FABS(wave[i])); } break; case POLAR: polar=(Polar*) obj->data; for (i=0; i<obj->size; i++) { polar[i].abs=LG(polar[i].abs); } break; case SURFACE: surface=(Surface*) obj->data; zsize=surface->xsize*(surface->ysize); for (i=0; i<zsize; i++) surface->z[i]=LG(surface->z[i]); break; case COMPLEX: cpx=(Complex*) obj->data; for (i=0; i<obj->size; i++) { abs=CABS(cpx[i]); arg=ATAN2(cpx[i]); cpx[i].real=LG(abs); cpx[i].imag=arg; } break; default: ESWEEP_NOT_THIS_TYPE(obj->type, ERR_NOT_ON_THIS_TYPE); } ESWEEP_ASSERT(correctFpException(obj), ERR_FP); return ERR_OK; }
int load_png_graphics (char *txt_filename, char *png_filename) { png_uint_32 row; png_structp png_ptr; png_infop info_ptr; unsigned int sig_read = 0; png_uint_32 width, height; int bit_depth, color_type, interlace_type; FILE *fp, *txt_fp; png_bytep *row_pointers; if ((fp = fopen(png_filename, "rb")) == NULL) return (ERROR); if ((txt_fp = fopen(txt_filename, "r")) == NULL) return (ERROR); /* Create and initialize the png_struct with the desired error handler * functions. If you want to use the default stderr and longjump method, * you can supply NULL for the last three parameters. We also supply the * the compiler header file version, so that we know if the application * was compiled with a compatible version of the library. REQUIRED */ png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp) user_error_ptr, user_error_fn, user_warning_fn); if (png_ptr == NULL) { fclose(fp); return (ERROR); } /* Allocate/initialize the memory for image information. REQUIRED. */ info_ptr = png_create_info_struct(png_ptr); if (info_ptr == NULL) { fclose(fp); #if defined (commentout) png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL); #endif png_destroy_read_struct(&png_ptr, NULL, NULL); return (ERROR); } /* Set error handling if you are using the setjmp/longjmp method (this is * the normal method of doing things with libpng). REQUIRED unless you * set up your own error handlers in the png_create_read_struct() earlier. */ if (setjmp(png_jmpbuf(png_ptr))) { /* Free all of the memory associated with the png_ptr and info_ptr */ #if defined (commentout) png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL); #endif png_destroy_read_struct(&png_ptr, &info_ptr, NULL); fclose(fp); /* If we get here, we had a problem reading the file */ return (ERROR); } /* Set up the input control if you are using standard C streams */ png_init_io(png_ptr, fp); /* If we have already read some of the signature */ png_set_sig_bytes(png_ptr, sig_read); /* OK, you're doing it the hard way, with the lower-level functions */ /* The call to png_read_info() gives us all of the information from the * PNG file before the first IDAT (image data chunk). REQUIRED */ png_read_info(png_ptr, info_ptr); #if defined (commentout) png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, int_p_NULL, int_p_NULL); #endif png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL); printf ("PNG Header: %d x %d, bd=%d, ct=%d\n", (int)height, (int)width, bit_depth, color_type); /* Set up the data transformations you want. Note that these are all * optional. Only call them if you want/need them. Many of the * transformations only work on specific types of images, and many * are mutually exclusive. */ /* tell libpng to strip 16 bit/color files down to 8 bits/color */ // png_set_strip_16(png_ptr); /* Strip alpha bytes from the input data without combining with the * background (not recommended). */ // png_set_strip_alpha(png_ptr); /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single * byte into separate bytes (useful for paletted and grayscale images). */ // png_set_packing(png_ptr); /* Change the order of packed pixels to least significant bit first * (not useful if you are using png_set_packing). */ // png_set_packswap(png_ptr); /* Require color fmt w/ palette */ if (color_type != PNG_COLOR_TYPE_PALETTE) { printf ("Error - png image wasn't PNG_COLOR_TYPE_PALETTE\n"); /* Free all of the memory associated with the png_ptr and info_ptr */ #if defined (commentout) png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL); #endif png_destroy_read_struct(&png_ptr, &info_ptr, NULL); fclose(fp); /* If we get here, we had a problem reading the file */ return (ERROR); } /* Require 1 byte per pixel */ if (bit_depth != 8) { printf ("Error - png image wasn't bit_depth = 8\n"); /* Free all of the memory associated with the png_ptr and info_ptr */ #if defined (commentout) png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL); #endif png_destroy_read_struct(&png_ptr, &info_ptr, NULL); fclose(fp); /* If we get here, we had a problem reading the file */ return (ERROR); } /* The easiest way to read the image: */ row_pointers = (png_byte**)malloc (sizeof(void*)*height); for (row = 0; row < height; row++) { row_pointers[row] = (png_byte*)png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr)); } png_read_image(png_ptr, row_pointers); #if defined (commentout) for (col = 0; col < 16; col++) { printf (" %02x ",row_pointers[0][col]); } printf ("\n"); for (col = 0; col < 16; col++) { printf ("%3d ",row_pointers[0][col]); } printf ("\n"); #endif /* read rest of file, and get additional chunks in info_ptr - REQUIRED */ png_read_end(png_ptr, info_ptr); /* close the png file */ fclose(fp); /* get the icons out of the png */ #ifdef LG #undef LG #endif #define LG(typ,grp,id) load_png_graphic(typ,grp,id,txt_fp,row_pointers,height,width) LG(CST_GREEN,GROUP_BARE,LCT_GREEN_G); LG(CST_FIRE_1,GROUP_FIRE,LCT_FIRE_1_G); LG(CST_FIRE_2,GROUP_FIRE,LCT_FIRE_2_G); LG(CST_FIRE_3,GROUP_FIRE,LCT_FIRE_3_G); LG(CST_FIRE_4,GROUP_FIRE,LCT_FIRE_4_G); LG(CST_FIRE_5,GROUP_FIRE,LCT_FIRE_5_G); LG(CST_FIRE_DONE1,GROUP_FIRE,LCT_FIRE_DONE1_G); LG(CST_FIRE_DONE2,GROUP_FIRE,LCT_FIRE_DONE2_G); LG(CST_FIRE_DONE3,GROUP_FIRE,LCT_FIRE_DONE3_G); LG(CST_FIRE_DONE4,GROUP_FIRE,LCT_FIRE_DONE4_G); LG(CST_BURNT,GROUP_BURNT,LCT_BURNT_G); LG(CST_PARKLAND_PLANE,GROUP_PARKLAND,LCT_PARKLAND_PLANE_G); LG(CST_PARKLAND_LAKE,GROUP_PARKLAND,LCT_PARKLAND_LAKE_G); LG(CST_POWERL_H_L,GROUP_POWER_LINE,LCT_POWERL_H_L_G); LG(CST_POWERL_V_L,GROUP_POWER_LINE,LCT_POWERL_V_L_G); LG(CST_POWERL_LD_L,GROUP_POWER_LINE,LCT_POWERL_LD_L_G); LG(CST_POWERL_RD_L,GROUP_POWER_LINE,LCT_POWERL_RD_L_G); LG(CST_POWERL_LU_L,GROUP_POWER_LINE,LCT_POWERL_LU_L_G); LG(CST_POWERL_RU_L,GROUP_POWER_LINE,LCT_POWERL_RU_L_G); LG(CST_POWERL_LDU_L,GROUP_POWER_LINE,LCT_POWERL_LDU_L_G); LG(CST_POWERL_LDR_L,GROUP_POWER_LINE,LCT_POWERL_LDR_L_G); LG(CST_POWERL_LUR_L,GROUP_POWER_LINE,LCT_POWERL_LUR_L_G); LG(CST_POWERL_UDR_L,GROUP_POWER_LINE,LCT_POWERL_UDR_L_G); LG(CST_POWERL_LUDR_L,GROUP_POWER_LINE,LCT_POWERL_LUDR_L_G); LG(CST_POWERL_H_D,GROUP_POWER_LINE,LCT_POWERL_H_D_G); LG(CST_POWERL_V_D,GROUP_POWER_LINE,LCT_POWERL_V_D_G); LG(CST_POWERL_LD_D,GROUP_POWER_LINE,LCT_POWERL_LD_D_G); LG(CST_POWERL_RD_D,GROUP_POWER_LINE,LCT_POWERL_RD_D_G); LG(CST_POWERL_LU_D,GROUP_POWER_LINE,LCT_POWERL_LU_D_G); LG(CST_POWERL_RU_D,GROUP_POWER_LINE,LCT_POWERL_RU_D_G); LG(CST_POWERL_LDU_D,GROUP_POWER_LINE,LCT_POWERL_LDU_D_G); LG(CST_POWERL_LDR_D,GROUP_POWER_LINE,LCT_POWERL_LDR_D_G); LG(CST_POWERL_LUR_D,GROUP_POWER_LINE,LCT_POWERL_LUR_D_G); LG(CST_POWERL_UDR_D,GROUP_POWER_LINE,LCT_POWERL_UDR_D_G); LG(CST_POWERL_LUDR_D,GROUP_POWER_LINE,LCT_POWERL_LUDR_D_G); LG(CST_RAIL_LR,GROUP_RAIL,LCT_RAIL_LR_G); LG(CST_RAIL_LU,GROUP_RAIL,LCT_RAIL_LU_G); LG(CST_RAIL_LD,GROUP_RAIL,LCT_RAIL_LD_G); LG(CST_RAIL_UD,GROUP_RAIL,LCT_RAIL_UD_G); LG(CST_RAIL_UR,GROUP_RAIL,LCT_RAIL_UR_G); LG(CST_RAIL_DR,GROUP_RAIL,LCT_RAIL_DR_G); LG(CST_RAIL_LUR,GROUP_RAIL,LCT_RAIL_LUR_G); LG(CST_RAIL_LDR,GROUP_RAIL,LCT_RAIL_LDR_G); LG(CST_RAIL_LUD,GROUP_RAIL,LCT_RAIL_LUD_G); LG(CST_RAIL_UDR,GROUP_RAIL,LCT_RAIL_UDR_G); LG(CST_RAIL_LUDR,GROUP_RAIL,LCT_RAIL_LUDR_G); LG(CST_ROAD_LR,GROUP_ROAD,LCT_ROAD_LR_G); LG(CST_ROAD_LU,GROUP_ROAD,LCT_ROAD_LU_G); LG(CST_ROAD_LD,GROUP_ROAD,LCT_ROAD_LD_G); LG(CST_ROAD_UD,GROUP_ROAD,LCT_ROAD_UD_G); LG(CST_ROAD_UR,GROUP_ROAD,LCT_ROAD_UR_G); LG(CST_ROAD_DR,GROUP_ROAD,LCT_ROAD_DR_G); LG(CST_ROAD_LUR,GROUP_ROAD,LCT_ROAD_LUR_G); LG(CST_ROAD_LDR,GROUP_ROAD,LCT_ROAD_LDR_G); LG(CST_ROAD_LUD,GROUP_ROAD,LCT_ROAD_LUD_G); LG(CST_ROAD_UDR,GROUP_ROAD,LCT_ROAD_UDR_G); LG(CST_ROAD_LUDR,GROUP_ROAD,LCT_ROAD_LUDR_G); LG(CST_TRACK_LR,GROUP_TRACK,LCT_TRACK_LR_G); LG(CST_TRACK_LU,GROUP_TRACK,LCT_TRACK_LU_G); LG(CST_TRACK_LD,GROUP_TRACK,LCT_TRACK_LD_G); LG(CST_TRACK_UD,GROUP_TRACK,LCT_TRACK_UD_G); LG(CST_TRACK_UR,GROUP_TRACK,LCT_TRACK_UR_G); LG(CST_TRACK_DR,GROUP_TRACK,LCT_TRACK_DR_G); LG(CST_TRACK_LUR,GROUP_TRACK,LCT_TRACK_LUR_G); LG(CST_TRACK_LDR,GROUP_TRACK,LCT_TRACK_LDR_G); LG(CST_TRACK_LUD,GROUP_TRACK,LCT_TRACK_LUD_G); LG(CST_TRACK_UDR,GROUP_TRACK,LCT_TRACK_UDR_G); LG(CST_TRACK_LUDR,GROUP_TRACK,LCT_TRACK_LUDR_G); LG(CST_WATER,GROUP_WATER,LCT_WATER_G); LG(CST_WATER_D,GROUP_WATER,LCT_WATER_D_G); LG(CST_WATER_R,GROUP_WATER,LCT_WATER_R_G); LG(CST_WATER_U,GROUP_WATER,LCT_WATER_U_G); LG(CST_WATER_L,GROUP_WATER,LCT_WATER_L_G); LG(CST_WATER_LR,GROUP_WATER,LCT_WATER_LR_G); LG(CST_WATER_UD,GROUP_WATER,LCT_WATER_UD_G); LG(CST_WATER_LD,GROUP_WATER,LCT_WATER_LD_G); LG(CST_WATER_RD,GROUP_WATER,LCT_WATER_RD_G); LG(CST_WATER_LU,GROUP_WATER,LCT_WATER_LU_G); LG(CST_WATER_UR,GROUP_WATER,LCT_WATER_UR_G); LG(CST_WATER_LUD,GROUP_WATER,LCT_WATER_LUD_G); LG(CST_WATER_LRD,GROUP_WATER,LCT_WATER_LRD_G); LG(CST_WATER_LUR,GROUP_WATER,LCT_WATER_LUR_G); LG(CST_WATER_URD,GROUP_WATER,LCT_WATER_URD_G); LG(CST_WATER_LURD,GROUP_WATER,LCT_WATER_LURD_G); LG(CST_BLACKSMITH_0,GROUP_BLACKSMITH,LCT_BLACKSMITH_0_G); LG(CST_BLACKSMITH_1,GROUP_BLACKSMITH,LCT_BLACKSMITH_1_G); LG(CST_BLACKSMITH_2,GROUP_BLACKSMITH,LCT_BLACKSMITH_2_G); LG(CST_BLACKSMITH_3,GROUP_BLACKSMITH,LCT_BLACKSMITH_3_G); LG(CST_BLACKSMITH_4,GROUP_BLACKSMITH,LCT_BLACKSMITH_4_G); LG(CST_BLACKSMITH_5,GROUP_BLACKSMITH,LCT_BLACKSMITH_5_G); LG(CST_BLACKSMITH_6,GROUP_BLACKSMITH,LCT_BLACKSMITH_6_G); LG(CST_CRICKET_1,GROUP_CRICKET,LCT_CRICKET_1_G); LG(CST_CRICKET_2,GROUP_CRICKET,LCT_CRICKET_2_G); LG(CST_CRICKET_3,GROUP_CRICKET,LCT_CRICKET_3_G); LG(CST_CRICKET_4,GROUP_CRICKET,LCT_CRICKET_4_G); LG(CST_CRICKET_5,GROUP_CRICKET,LCT_CRICKET_5_G); LG(CST_CRICKET_6,GROUP_CRICKET,LCT_CRICKET_6_G); LG(CST_CRICKET_7,GROUP_CRICKET,LCT_CRICKET_7_G); LG(CST_FIRESTATION_1,GROUP_FIRESTATION,LCT_FIRESTATION_1_G); LG(CST_FIRESTATION_2,GROUP_FIRESTATION,LCT_FIRESTATION_2_G); LG(CST_FIRESTATION_3,GROUP_FIRESTATION,LCT_FIRESTATION_3_G); LG(CST_FIRESTATION_4,GROUP_FIRESTATION,LCT_FIRESTATION_4_G); LG(CST_FIRESTATION_5,GROUP_FIRESTATION,LCT_FIRESTATION_5_G); LG(CST_FIRESTATION_6,GROUP_FIRESTATION,LCT_FIRESTATION_6_G); LG(CST_FIRESTATION_7,GROUP_FIRESTATION,LCT_FIRESTATION_7_G); LG(CST_FIRESTATION_8,GROUP_FIRESTATION,LCT_FIRESTATION_8_G); LG(CST_FIRESTATION_9,GROUP_FIRESTATION,LCT_FIRESTATION_9_G); LG(CST_FIRESTATION_10,GROUP_FIRESTATION,LCT_FIRESTATION_10_G); LG(CST_HEALTH,GROUP_HEALTH,LCT_HEALTH_G); LG(CST_MARKET_EMPTY,GROUP_MARKET,LCT_MARKET_EMPTY_G); LG(CST_MARKET_LOW,GROUP_MARKET,LCT_MARKET_LOW_G); LG(CST_MARKET_MED,GROUP_MARKET,LCT_MARKET_MED_G); LG(CST_MARKET_FULL,GROUP_MARKET,LCT_MARKET_FULL_G); LG(CST_MILL_0,GROUP_MILL,LCT_MILL_0_G); LG(CST_MILL_1,GROUP_MILL,LCT_MILL_1_G); LG(CST_MILL_2,GROUP_MILL,LCT_MILL_2_G); LG(CST_MILL_3,GROUP_MILL,LCT_MILL_3_G); LG(CST_MILL_4,GROUP_MILL,LCT_MILL_4_G); LG(CST_MILL_5,GROUP_MILL,LCT_MILL_5_G); LG(CST_MILL_6,GROUP_MILL,LCT_MILL_6_G); LG(CST_MONUMENT_0,GROUP_MONUMENT,LCT_MONUMENT_0_G); LG(CST_MONUMENT_1,GROUP_MONUMENT,LCT_MONUMENT_1_G); LG(CST_MONUMENT_2,GROUP_MONUMENT,LCT_MONUMENT_2_G); LG(CST_MONUMENT_3,GROUP_MONUMENT,LCT_MONUMENT_3_G); LG(CST_MONUMENT_4,GROUP_MONUMENT,LCT_MONUMENT_4_G); LG(CST_MONUMENT_5,GROUP_MONUMENT,LCT_MONUMENT_5_G); LG(CST_POTTERY_0,GROUP_POTTERY,LCT_POTTERY_0_G); LG(CST_POTTERY_1,GROUP_POTTERY,LCT_POTTERY_1_G); LG(CST_POTTERY_2,GROUP_POTTERY,LCT_POTTERY_2_G); LG(CST_POTTERY_3,GROUP_POTTERY,LCT_POTTERY_3_G); LG(CST_POTTERY_4,GROUP_POTTERY,LCT_POTTERY_4_G); LG(CST_POTTERY_5,GROUP_POTTERY,LCT_POTTERY_5_G); LG(CST_POTTERY_6,GROUP_POTTERY,LCT_POTTERY_6_G); LG(CST_POTTERY_7,GROUP_POTTERY,LCT_POTTERY_7_G); LG(CST_POTTERY_8,GROUP_POTTERY,LCT_POTTERY_8_G); LG(CST_POTTERY_9,GROUP_POTTERY,LCT_POTTERY_9_G); LG(CST_POTTERY_10,GROUP_POTTERY,LCT_POTTERY_10_G); LG(CST_RECYCLE,GROUP_RECYCLE,LCT_RECYCLE_G); LG(CST_SCHOOL,GROUP_SCHOOL,LCT_SCHOOL_G); LG(CST_SHANTY,GROUP_SHANTY,LCT_SHANTY_G); LG(CST_SUBSTATION_R,GROUP_SUBSTATION,LCT_SUBSTATION_R_G); LG(CST_SUBSTATION_G,GROUP_SUBSTATION,LCT_SUBSTATION_G_G); LG(CST_SUBSTATION_RG,GROUP_SUBSTATION,LCT_SUBSTATION_RG_G); LG(CST_WINDMILL_1_G,GROUP_WINDMILL,LCT_WINDMILL_1_G_G); LG(CST_WINDMILL_2_G,GROUP_WINDMILL,LCT_WINDMILL_2_G_G); LG(CST_WINDMILL_3_G,GROUP_WINDMILL,LCT_WINDMILL_3_G_G); LG(CST_WINDMILL_1_RG,GROUP_WINDMILL,LCT_WINDMILL_1_RG_G); LG(CST_WINDMILL_2_RG,GROUP_WINDMILL,LCT_WINDMILL_2_RG_G); LG(CST_WINDMILL_3_RG,GROUP_WINDMILL,LCT_WINDMILL_3_RG_G); LG(CST_WINDMILL_1_R,GROUP_WINDMILL,LCT_WINDMILL_1_R_G); LG(CST_WINDMILL_2_R,GROUP_WINDMILL,LCT_WINDMILL_2_R_G); LG(CST_WINDMILL_3_R,GROUP_WINDMILL,LCT_WINDMILL_3_R_G); LG(CST_WINDMILL_1_W,GROUP_WINDMILL,LCT_WINDMILL_1_W_G); LG(CST_WINDMILL_2_W,GROUP_WINDMILL,LCT_WINDMILL_2_W_G); LG(CST_WINDMILL_3_W,GROUP_WINDMILL,LCT_WINDMILL_3_W_G); LG(CST_INDUSTRY_L_C,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_C_G); LG(CST_INDUSTRY_L_Q1,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_Q1_G); LG(CST_INDUSTRY_L_Q2,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_Q2_G); LG(CST_INDUSTRY_L_Q3,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_Q3_G); LG(CST_INDUSTRY_L_Q4,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_Q4_G); LG(CST_INDUSTRY_L_L1,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_L1_G); LG(CST_INDUSTRY_L_L2,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_L2_G); LG(CST_INDUSTRY_L_L3,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_L3_G); LG(CST_INDUSTRY_L_L4,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_L4_G); LG(CST_INDUSTRY_L_M1,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_M1_G); LG(CST_INDUSTRY_L_M2,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_M2_G); LG(CST_INDUSTRY_L_M3,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_M3_G); LG(CST_INDUSTRY_L_M4,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_M4_G); LG(CST_INDUSTRY_L_H1,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_H1_G); LG(CST_INDUSTRY_L_H2,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_H2_G); LG(CST_INDUSTRY_L_H3,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_H3_G); LG(CST_INDUSTRY_L_H4,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_H4_G); LG(CST_RESIDENCE_LL,GROUP_RESIDENCE_LL,LCT_RESIDENCE_LL_G); LG(CST_RESIDENCE_ML,GROUP_RESIDENCE_ML,LCT_RESIDENCE_ML_G); LG(CST_RESIDENCE_HL,GROUP_RESIDENCE_HL,LCT_RESIDENCE_HL_G); LG(CST_RESIDENCE_LH,GROUP_RESIDENCE_LH,LCT_RESIDENCE_LH_G); LG(CST_RESIDENCE_MH,GROUP_RESIDENCE_MH,LCT_RESIDENCE_MH_G); LG(CST_RESIDENCE_HH,GROUP_RESIDENCE_HH,LCT_RESIDENCE_HH_G); LG(CST_UNIVERSITY,GROUP_UNIVERSITY,LCT_UNIVERSITY_G); LG(CST_COALMINE_EMPTY,GROUP_COALMINE,LCT_COALMINE_EMPTY_G); LG(CST_COALMINE_LOW,GROUP_COALMINE,LCT_COALMINE_LOW_G); LG(CST_COALMINE_MED,GROUP_COALMINE,LCT_COALMINE_MED_G); LG(CST_COALMINE_FULL,GROUP_COALMINE,LCT_COALMINE_FULL_G); LG(CST_COMMUNE_1,GROUP_COMMUNE,LCT_COMMUNE_1_G); LG(CST_COMMUNE_2,GROUP_COMMUNE,LCT_COMMUNE_2_G); LG(CST_COMMUNE_3,GROUP_COMMUNE,LCT_COMMUNE_3_G); LG(CST_COMMUNE_4,GROUP_COMMUNE,LCT_COMMUNE_4_G); LG(CST_COMMUNE_5,GROUP_COMMUNE,LCT_COMMUNE_5_G); LG(CST_COMMUNE_6,GROUP_COMMUNE,LCT_COMMUNE_6_G); LG(CST_COMMUNE_7,GROUP_COMMUNE,LCT_COMMUNE_7_G); LG(CST_COMMUNE_8,GROUP_COMMUNE,LCT_COMMUNE_8_G); LG(CST_COMMUNE_9,GROUP_COMMUNE,LCT_COMMUNE_9_G); LG(CST_COMMUNE_10,GROUP_COMMUNE,LCT_COMMUNE_10_G); LG(CST_COMMUNE_11,GROUP_COMMUNE,LCT_COMMUNE_11_G); LG(CST_COMMUNE_12,GROUP_COMMUNE,LCT_COMMUNE_12_G); LG(CST_COMMUNE_13,GROUP_COMMUNE,LCT_COMMUNE_13_G); LG(CST_COMMUNE_14,GROUP_COMMUNE,LCT_COMMUNE_14_G); LG(CST_EX_PORT,GROUP_PORT,LCT_EX_PORT_G); LG(CST_FARM_O0,GROUP_ORGANIC_FARM,LCT_FARM_O0_G); LG(CST_FARM_O1,GROUP_ORGANIC_FARM,LCT_FARM_O1_G); LG(CST_FARM_O2,GROUP_ORGANIC_FARM,LCT_FARM_O2_G); LG(CST_FARM_O3,GROUP_ORGANIC_FARM,LCT_FARM_O3_G); LG(CST_FARM_O4,GROUP_ORGANIC_FARM,LCT_FARM_O4_G); LG(CST_FARM_O5,GROUP_ORGANIC_FARM,LCT_FARM_O5_G); LG(CST_FARM_O6,GROUP_ORGANIC_FARM,LCT_FARM_O6_G); LG(CST_FARM_O7,GROUP_ORGANIC_FARM,LCT_FARM_O7_G); LG(CST_FARM_O8,GROUP_ORGANIC_FARM,LCT_FARM_O8_G); LG(CST_FARM_O9,GROUP_ORGANIC_FARM,LCT_FARM_O9_G); LG(CST_FARM_O10,GROUP_ORGANIC_FARM,LCT_FARM_O10_G); LG(CST_FARM_O11,GROUP_ORGANIC_FARM,LCT_FARM_O11_G); LG(CST_FARM_O12,GROUP_ORGANIC_FARM,LCT_FARM_O12_G); LG(CST_FARM_O13,GROUP_ORGANIC_FARM,LCT_FARM_O13_G); LG(CST_FARM_O14,GROUP_ORGANIC_FARM,LCT_FARM_O14_G); LG(CST_FARM_O15,GROUP_ORGANIC_FARM,LCT_FARM_O15_G); LG(CST_FARM_O16,GROUP_ORGANIC_FARM,LCT_FARM_O16_G); LG(CST_INDUSTRY_H_C,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_C_G); LG(CST_INDUSTRY_H_L1,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L1_G); LG(CST_INDUSTRY_H_L2,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L2_G); LG(CST_INDUSTRY_H_L3,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L3_G); LG(CST_INDUSTRY_H_L4,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L4_G); LG(CST_INDUSTRY_H_L5,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L5_G); LG(CST_INDUSTRY_H_L6,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L6_G); LG(CST_INDUSTRY_H_L7,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L7_G); LG(CST_INDUSTRY_H_L8,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L8_G); LG(CST_INDUSTRY_H_M1,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M1_G); LG(CST_INDUSTRY_H_M2,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M2_G); LG(CST_INDUSTRY_H_M3,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M3_G); LG(CST_INDUSTRY_H_M4,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M4_G); LG(CST_INDUSTRY_H_M5,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M5_G); LG(CST_INDUSTRY_H_M6,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M6_G); LG(CST_INDUSTRY_H_M7,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M7_G); LG(CST_INDUSTRY_H_M8,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M8_G); LG(CST_INDUSTRY_H_H1,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H1_G); LG(CST_INDUSTRY_H_H2,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H2_G); LG(CST_INDUSTRY_H_H3,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H3_G); LG(CST_INDUSTRY_H_H4,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H4_G); LG(CST_INDUSTRY_H_H5,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H5_G); LG(CST_INDUSTRY_H_H6,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H6_G); LG(CST_INDUSTRY_H_H7,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H7_G); LG(CST_INDUSTRY_H_H8,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H8_G); LG(CST_OREMINE_1,GROUP_OREMINE,LCT_OREMINE_1_G); LG(CST_OREMINE_2,GROUP_OREMINE,LCT_OREMINE_2_G); LG(CST_OREMINE_3,GROUP_OREMINE,LCT_OREMINE_3_G); LG(CST_OREMINE_4,GROUP_OREMINE,LCT_OREMINE_4_G); LG(CST_OREMINE_5,GROUP_OREMINE,LCT_OREMINE_5_G); LG(CST_OREMINE_6,GROUP_OREMINE,LCT_OREMINE_6_G); LG(CST_OREMINE_7,GROUP_OREMINE,LCT_OREMINE_7_G); LG(CST_OREMINE_8,GROUP_OREMINE,LCT_OREMINE_8_G); LG(CST_POWERS_COAL_EMPTY,GROUP_COAL_POWER,LCT_POWERS_COAL_EMPTY_G); LG(CST_POWERS_COAL_LOW,GROUP_COAL_POWER,LCT_POWERS_COAL_LOW_G); LG(CST_POWERS_COAL_MED,GROUP_COAL_POWER,LCT_POWERS_COAL_MED_G); LG(CST_POWERS_COAL_FULL,GROUP_COAL_POWER,LCT_POWERS_COAL_FULL_G); LG(CST_POWERS_SOLAR,GROUP_SOLAR_POWER,LCT_POWERS_SOLAR_G); LG(CST_ROCKET_1,GROUP_ROCKET,LCT_ROCKET_1_G); LG(CST_ROCKET_2,GROUP_ROCKET,LCT_ROCKET_2_G); LG(CST_ROCKET_3,GROUP_ROCKET,LCT_ROCKET_3_G); LG(CST_ROCKET_4,GROUP_ROCKET,LCT_ROCKET_4_G); LG(CST_ROCKET_5,GROUP_ROCKET,LCT_ROCKET_5_G); LG(CST_ROCKET_6,GROUP_ROCKET,LCT_ROCKET_6_G); LG(CST_ROCKET_7,GROUP_ROCKET,LCT_ROCKET_7_G); LG(CST_ROCKET_FLOWN,GROUP_ROCKET,LCT_ROCKET_FLOWN_G); LG(CST_TIP_0,GROUP_TIP,LCT_TIP_0_G); LG(CST_TIP_1,GROUP_TIP,LCT_TIP_1_G); LG(CST_TIP_2,GROUP_TIP,LCT_TIP_2_G); LG(CST_TIP_3,GROUP_TIP,LCT_TIP_3_G); LG(CST_TIP_4,GROUP_TIP,LCT_TIP_4_G); LG(CST_TIP_5,GROUP_TIP,LCT_TIP_5_G); LG(CST_TIP_6,GROUP_TIP,LCT_TIP_6_G); LG(CST_TIP_7,GROUP_TIP,LCT_TIP_7_G); LG(CST_TIP_8,GROUP_TIP,LCT_TIP_8_G); // main_t #undef LG #if defined (commentout) /* PROCESS IMAGE HERE */ while (!feof(txt_fp)) { char buf[128]; char *fnp,*rip,*cip; int ri,ci; /* Get line from text file */ fgets (buf,128,txt_fp); /* Tokenize */ fnp = strtok(buf," \t"); if (!fnp || *fnp == '#') continue; if (*fnp == '@') break; rip = strtok(NULL," \t"); if (!rip) continue; cip = strtok(NULL," \t"); if (!cip) continue; ri = atoi(rip); ci = atoi(cip); /* Copy icon */ if (!strcmp(fnp,LCT_GREEN_G)) { int r,c; char* p; main_types[CST_GREEN].graphic=malloc(16*16); p = main_types[CST_GREEN].graphic; for (r=ri*16;r<ri*16+16;r++) { for (c=ci*16;c<ci*16+16;c++) { *p++ = row_pointers[r][c]; } } } } #endif /* Free the memory */ for (row = 0; row < height; row++) { png_free(png_ptr, row_pointers[row]); } free(row_pointers); /* clean up after the read, and free any memory allocated - REQUIRED */ #if defined (commentout) png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL); #endif png_destroy_read_struct(&png_ptr, &info_ptr, NULL); /* that's it */ return (OK); }
void selfie(libmaus2::util::ArgParser const & arg, std::string const & fn) { std::string const compactfn = fn + ".compact"; std::string const compactmetafn = compactfn + ".meta"; if ( ! libmaus2::util::GetFileSize::fileExists(compactfn) || libmaus2::util::GetFileSize::isOlder(compactfn,fn) ) { libmaus2::fastx::FastAToCompact4BigBandBiDir::fastaToCompact4BigBandBiDir( std::vector<std::string>(1,fn), &(std::cerr), false /* single strand */, compactfn ); } uint64_t const numthreads = arg.uniqueArgPresent("t") ? arg.getUnsignedNumericArg<uint64_t>("t") : libmaus2::suffixsort::bwtb3m::BwtMergeSortOptions::getDefaultNumThreads(); std::string const bwtfn = fn + ".bwt"; std::string const bwtmetafn = bwtfn + ".meta"; libmaus2::suffixsort::bwtb3m::BwtMergeSortResult res; if ( ! libmaus2::util::GetFileSize::fileExists(bwtmetafn) || libmaus2::util::GetFileSize::isOlder(bwtmetafn,compactfn) ) { libmaus2::suffixsort::bwtb3m::BwtMergeSortOptions options( compactfn, 16*1024ull*1024ull*1024ull, // mem // libmaus2::suffixsort::bwtb3m::BwtMergeSortOptions::getDefaultMem(), numthreads, "compactstream", false /* bwtonly */, std::string("mem:tmp_"), std::string(), // sparse bwtfn, 16 /* isa */, 16 /* sa */ ); res = libmaus2::suffixsort::bwtb3m::BwtMergeSort::computeBwt(options,&std::cerr); res.serialise(bwtmetafn); } else { res.deserialise(bwtmetafn); } //libmaus2::fastx::FastAIndex::unique_ptr_type PFAI(libmaus2::fastx::FastAIndex::load(fn+".fai")); libmaus2::fastx::DNAIndexMetaDataBigBandBiDir::unique_ptr_type Pmeta(libmaus2::fastx::DNAIndexMetaDataBigBandBiDir::load(compactmetafn)); libmaus2::rank::DNARank::unique_ptr_type Prank(res.loadDNARank(numthreads)); libmaus2::suffixsort::bwtb3m::BwtMergeSortResult::BareSimpleSampledSuffixArray BSSSA(res.loadBareSimpleSuffixArray()); uint64_t const n = Prank->size(); libmaus2::autoarray::AutoArray<char> A(n,false); libmaus2::bitio::CompactDecoderWrapper CDW(compactfn); CDW.read(A.begin(),n); assert ( CDW.gcount() == static_cast<int64_t>(n) ); uint64_t const minfreq = 2; uint64_t const minlen = 20; uint64_t const limit = 32; uint64_t const minsplitlength = 28; uint64_t const minsplitsize = 10; uint64_t const maxxdist = 1000; uint64_t const activemax = 1; uint64_t const fracmul = 95; uint64_t const fracdiv = 100; bool const selfcheck = true; uint64_t const chainminscore = arg.uniqueArgPresent("chainminscore") ? arg.getUnsignedNumericArg<uint64_t>("chainminscore") : 20; uint64_t const maxocc = 500; uint64_t const minprintlength = 1024; uint64_t const algndommul = 95; uint64_t const algndomdiv = 100; uint64_t const chaindommul = 95; uint64_t const chaindomdiv = 100; double const maxerr = arg.uniqueArgPresent("maxerr") ? arg.getParsedArg<double>("maxerr") : std::numeric_limits<double>::max(); uint64_t const cachek = arg.uniqueArgPresent("K") ? arg.getUnsignedNumericArg<uint64_t>("K") : 12; uint64_t const maxpacksize = arg.uniqueArgPresent("P") ? arg.getUnsignedNumericArg<uint64_t>("P") : 128ull*1024ull*1024ull; std::cerr << "[V] generating " << cachek << "-mer cache..."; libmaus2::rank::DNARankKmerCache::unique_ptr_type Pcache(new libmaus2::rank::DNARankKmerCache(*Prank,cachek,numthreads)); std::cerr << "done." << std::endl; std::string const deftmp = libmaus2::util::ArgInfo::getDefaultTmpFileName(arg.progname); libmaus2::util::TempFileNameGenerator tmpgen(deftmp,3); std::string const sorttmp = tmpgen.getFileName(); libmaus2::util::TempFileRemovalContainer::addTempFile(sorttmp); libmaus2::sorting::SortingBufferedOutputFile<CoordinatePair> CPS(sorttmp); libmaus2::parallel::PosixSpinLock CPSlock; uint64_t acc_s = 0; for ( uint64_t zz = 0; zz < Pmeta->S.size(); ) { uint64_t zze = zz; uint64_t pack_s = Pmeta->S[zze++].l; while ( zze < Pmeta->S.size() && pack_s + Pmeta->S[zze].l <= maxpacksize ) pack_s += Pmeta->S[zze++].l; // std::cerr << "[V] " << zz << "-" << zze << " pack_s=" << pack_s << std::endl; zz = zze; uint64_t const low = acc_s; uint64_t const high = acc_s + pack_s; std::cerr << "[V] low=" << low << " high=" << high << " acc_s=" << acc_s << " pack_s=" << pack_s << std::endl; std::string const activefn = libmaus2::rank::DNARankSMEMComputation::activeParallel(tmpgen,*Pcache,A.begin(),low,high,minfreq,minlen,numthreads,maxxdist + 2*(minlen-1)); libmaus2::gamma::GammaIntervalDecoder::unique_ptr_type Pdec(new libmaus2::gamma::GammaIntervalDecoder(std::vector<std::string>(1,activefn),0/*offset */,1 /* numthreads */)); std::string const sortinfn = tmpgen.getFileName(true); libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>::unique_ptr_type sptr( new libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>(sortinfn) ); { std::pair<uint64_t,uint64_t> P; while ( Pdec->getNext(P) ) { sptr->put( GammaInterval(P.first,P.second) ); } } libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>::merger_ptr_type Pmerger( sptr->getMerger() ); struct LockedGet { libmaus2::parallel::PosixSpinLock lock; // libmaus2::gamma::GammaIntervalDecoder& dec; libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>::merger_ptr_type & Pmerger; LockedGet(libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>::merger_ptr_type & rPmerger) : Pmerger(rPmerger) { } bool getNext(std::pair<uint64_t,uint64_t> & P) { bool ok = false; { libmaus2::parallel::ScopePosixSpinLock slock(lock); GammaInterval Q; ok = Pmerger->getNext(Q); if ( ok ) { P.first = Q.first; P.second = Q.second; } } return ok; } }; libmaus2::autoarray::AutoArray < std::pair<uint64_t,uint64_t> > VP(numthreads); LockedGet LG(Pmerger); libmaus2::fastx::CoordinateCacheBiDir cocache(*Prank,*Pmeta,16 /* blockshfit */); typedef libmaus2::suffixsort::bwtb3m::BwtMergeSortResult::BareSimpleSampledSuffixArray sa_type; typedef libmaus2::lcs::SMEMProcessor<sa_type> smem_proc_type; libmaus2::autoarray::AutoArray < smem_proc_type::unique_ptr_type > Aproc(numthreads); for ( uint64_t i = 0; i < numthreads; ++i ) { smem_proc_type::unique_ptr_type proc(new smem_proc_type( *Pmeta,cocache,*Prank,BSSSA,A.begin(),maxxdist,activemax,fracmul,fracdiv,selfcheck,chainminscore,maxocc,algndommul,algndomdiv,chaindommul,chaindomdiv, libmaus2::lcs::NNP::getDefaultMaxWindowError(),libmaus2::lcs::NNP::getDefaultMaxBack(),false /* domsameref */ ) ); Aproc[i] = UNIQUE_PTR_MOVE(proc); } stateVec.resize(numthreads); for ( uint64_t i = 0; i < numthreads; ++i ) setState(i,"idle"); #if defined(_OPENMP) #pragma omp parallel num_threads(numthreads) #endif { uint64_t const tid = #if defined(_OPENMP) omp_get_thread_num() #else 0 #endif ; std::pair<uint64_t,uint64_t> & P = VP[tid]; smem_proc_type & proc = *(Aproc[tid]); struct SelfieVerbosity : public smem_proc_type::Verbosity { uint64_t tid; std::string prefix; SelfieVerbosity(uint64_t const rtid, std::string const & rprefix) : tid(rtid), prefix(rprefix) { } void operator()(libmaus2::rank::DNARankMEM const & smem, uint64_t const z) const { std::ostringstream ostr; ostr << prefix << "\t" << z << "\t" << smem; setState(tid,ostr.str()); printState(); } }; while ( LG.getNext(P) ) { uint64_t const smemleft = std::max(static_cast<int64_t>(0),static_cast<int64_t>(P.first)-static_cast<int64_t>(minlen-1)); uint64_t const smemright = std::min(P.second+minlen,n); std::ostringstream msgstr; msgstr << "[" << smemleft << "," << smemright << ")"; setState(tid,msgstr.str()); printState(); libmaus2::rank::DNARankSMEMComputation::SMEMEnumerator<char const *> senum( *Prank,A.begin(), smemleft, smemright, minfreq, minlen, limit, minsplitlength, minsplitsize); SelfieVerbosity SV(tid,msgstr.str()); proc.process(senum,A.begin(),n,minprintlength,maxerr,SV); // proc.printAlignments(minprintlength); std::pair<libmaus2::lcs::ChainAlignment const *, libmaus2::lcs::ChainAlignment const *> const AP = proc.getAlignments(); for ( libmaus2::lcs::ChainAlignment const * it = AP.first; it != AP.second; ++it ) { libmaus2::lcs::ChainAlignment const & CA = *it; libmaus2::lcs::NNPAlignResult const & res = CA.res; std::vector<libmaus2::fastx::DNAIndexMetaDataBigBandBiDir::Coordinates> const VA = Pmeta->mapCoordinatePairToList(res.abpos,res.aepos); std::vector<libmaus2::fastx::DNAIndexMetaDataBigBandBiDir::Coordinates> const VB = Pmeta->mapCoordinatePairToList(res.bbpos,res.bepos); if ( VA.size() == 1 && VB.size() == 1 ) { CoordinatePair CP(VA[0],VB[0],res); libmaus2::parallel::ScopePosixSpinLock slock(CPSlock); CPS.put(CP); } } setState(tid,"idle"); printState(); #if 0 std::cerr << "P=[" << P.first << "," << P.second << ")" << std::endl; { std::vector<libmaus2::rank::DNARankMEM> SMEM; libmaus2::rank::DNARankSMEMComputation::smemLimitedParallel( *Prank, *Pcache, A.begin(), P.first, P.second, n, minfreq, minlen, limit, SMEM, 1 /* threads */); std::cerr << "[V] number of SMEMs is " << SMEM.size() << std::endl; // deallocate k-mer cache // Pcache.reset(); std::vector<libmaus2::rank::DNARankMEM> SMEMsplit; libmaus2::rank::DNARankSMEMComputation::smemLimitedParallelSplit(*Prank,A.begin(),P.first,P.second,minlen,limit,minsplitlength,minsplitsize,SMEM,SMEMsplit,1 /* threads */); std::cerr << "[V] number of split SMEMs is " << SMEMsplit.size() << std::endl; // insert split SMEMs into regular SMEMs std::copy(SMEMsplit.begin(),SMEMsplit.end(),std::back_insert_iterator< std::vector<libmaus2::rank::DNARankMEM> >(SMEM)); //libmaus2::sorting::InPlaceParallelSort::inplacesort2(SMEM.begin(),SMEM.end(),numthreads,libmaus2::rank::DNARankMEMPosComparator()); std::sort(SMEM.begin(),SMEM.end(),libmaus2::rank::DNARankMEMPosComparator()); SMEM.resize(std::unique(SMEM.begin(),SMEM.end())-SMEM.begin()); libmaus2::rank::DNARankSMEMComputation::SMEMEnumerator<char const *> senum( *Prank,A.begin(), std::max(static_cast<int64_t>(0),static_cast<int64_t>(P.first)-static_cast<int64_t>(minlen-1)), std::min(P.second+minlen,n), minfreq, minlen, limit, minsplitlength, minsplitsize); libmaus2::rank::DNARankMEM smem; uint64_t c = 0; while ( senum.getNext(smem) ) { // std::cerr << "ccc=" << smem << std::endl; if ( c >= SMEM.size() || smem != SMEM[c] ) { std::cerr << "mismatch " << c << " " << smem; if ( c < SMEM.size() ) std::cerr << " != " << SMEM[c]; else std::cerr << " ???"; std::cerr << std::endl; } else { std::cerr << "match " << c << " " << smem << " " << SMEM[c] << std::endl; } ++c; } std::cerr << "c=" << c << " V=" << SMEM.size() << std::endl; } #endif } } acc_s += pack_s; } libmaus2::sorting::SortingBufferedOutputFile<CoordinatePair>::merger_ptr_type Pmerger(CPS.getMerger()); CoordinatePair CP; while ( Pmerger->getNext(CP) ) { std::ostringstream ostr; CP.A.print(ostr); ostr << " "; CP.B.print(ostr); ostr << " "; ostr << CP.res.getErrorRate(); std::cout << ostr.str() << std::endl; } }
/** * The original lincity engine was loading it's tileset here. We still have this * function because it had the strange side effect of initializing group numbers * in the main_types array. */ int load_png_graphics (void) { LG(CST_GREEN,GROUP_BARE,LCT_GREEN_G); LG(CST_FIRE_1,GROUP_FIRE,LCT_FIRE_1_G); LG(CST_FIRE_2,GROUP_FIRE,LCT_FIRE_2_G); LG(CST_FIRE_3,GROUP_FIRE,LCT_FIRE_3_G); LG(CST_FIRE_4,GROUP_FIRE,LCT_FIRE_4_G); LG(CST_FIRE_5,GROUP_FIRE,LCT_FIRE_5_G); LG(CST_FIRE_DONE1,GROUP_FIRE,LCT_FIRE_DONE1_G); LG(CST_FIRE_DONE2,GROUP_FIRE,LCT_FIRE_DONE2_G); LG(CST_FIRE_DONE3,GROUP_FIRE,LCT_FIRE_DONE3_G); LG(CST_FIRE_DONE4,GROUP_FIRE,LCT_FIRE_DONE4_G); LG(CST_BURNT,GROUP_BURNT,LCT_BURNT_G); LG(CST_PARKLAND_PLANE,GROUP_PARKLAND,LCT_PARKLAND_PLANE_G); LG(CST_PARKLAND_LAKE,GROUP_PARKLAND,LCT_PARKLAND_LAKE_G); LG(CST_POWERL_H_L,GROUP_POWER_LINE,LCT_POWERL_H_L_G); LG(CST_POWERL_V_L,GROUP_POWER_LINE,LCT_POWERL_V_L_G); LG(CST_POWERL_LD_L,GROUP_POWER_LINE,LCT_POWERL_LD_L_G); LG(CST_POWERL_RD_L,GROUP_POWER_LINE,LCT_POWERL_RD_L_G); LG(CST_POWERL_LU_L,GROUP_POWER_LINE,LCT_POWERL_LU_L_G); LG(CST_POWERL_RU_L,GROUP_POWER_LINE,LCT_POWERL_RU_L_G); LG(CST_POWERL_LDU_L,GROUP_POWER_LINE,LCT_POWERL_LDU_L_G); LG(CST_POWERL_LDR_L,GROUP_POWER_LINE,LCT_POWERL_LDR_L_G); LG(CST_POWERL_LUR_L,GROUP_POWER_LINE,LCT_POWERL_LUR_L_G); LG(CST_POWERL_UDR_L,GROUP_POWER_LINE,LCT_POWERL_UDR_L_G); LG(CST_POWERL_LUDR_L,GROUP_POWER_LINE,LCT_POWERL_LUDR_L_G); LG(CST_POWERL_H_D,GROUP_POWER_LINE,LCT_POWERL_H_D_G); LG(CST_POWERL_V_D,GROUP_POWER_LINE,LCT_POWERL_V_D_G); LG(CST_POWERL_LD_D,GROUP_POWER_LINE,LCT_POWERL_LD_D_G); LG(CST_POWERL_RD_D,GROUP_POWER_LINE,LCT_POWERL_RD_D_G); LG(CST_POWERL_LU_D,GROUP_POWER_LINE,LCT_POWERL_LU_D_G); LG(CST_POWERL_RU_D,GROUP_POWER_LINE,LCT_POWERL_RU_D_G); LG(CST_POWERL_LDU_D,GROUP_POWER_LINE,LCT_POWERL_LDU_D_G); LG(CST_POWERL_LDR_D,GROUP_POWER_LINE,LCT_POWERL_LDR_D_G); LG(CST_POWERL_LUR_D,GROUP_POWER_LINE,LCT_POWERL_LUR_D_G); LG(CST_POWERL_UDR_D,GROUP_POWER_LINE,LCT_POWERL_UDR_D_G); LG(CST_POWERL_LUDR_D,GROUP_POWER_LINE,LCT_POWERL_LUDR_D_G); LG(CST_RAIL_LR,GROUP_RAIL,LCT_RAIL_LR_G); LG(CST_RAIL_LU,GROUP_RAIL,LCT_RAIL_LU_G); LG(CST_RAIL_LD,GROUP_RAIL,LCT_RAIL_LD_G); LG(CST_RAIL_UD,GROUP_RAIL,LCT_RAIL_UD_G); LG(CST_RAIL_UR,GROUP_RAIL,LCT_RAIL_UR_G); LG(CST_RAIL_DR,GROUP_RAIL,LCT_RAIL_DR_G); LG(CST_RAIL_LUR,GROUP_RAIL,LCT_RAIL_LUR_G); LG(CST_RAIL_LDR,GROUP_RAIL,LCT_RAIL_LDR_G); LG(CST_RAIL_LUD,GROUP_RAIL,LCT_RAIL_LUD_G); LG(CST_RAIL_UDR,GROUP_RAIL,LCT_RAIL_UDR_G); LG(CST_RAIL_LUDR,GROUP_RAIL,LCT_RAIL_LUDR_G); LG(CST_RAIL_BRIDGE_LR,GROUP_RAIL_BRIDGE,LCT_RAIL_BRIDGE_LR_G); LG(CST_RAIL_BRIDGE_UD,GROUP_RAIL_BRIDGE,LCT_RAIL_BRIDGE_UD_G); LG(CST_RAIL_BRIDGE_LRPG,GROUP_RAIL_BRIDGE,LCT_RAIL_BRIDGE_LRPG_G); LG(CST_RAIL_BRIDGE_UDPG,GROUP_RAIL_BRIDGE,LCT_RAIL_BRIDGE_UDPG_G); LG(CST_RAIL_BRIDGE_I1LR,GROUP_RAIL,LCT_RAIL_BRIDGE_I1LR_G); LG(CST_RAIL_BRIDGE_O1LR,GROUP_RAIL,LCT_RAIL_BRIDGE_O1LR_G); LG(CST_RAIL_BRIDGE_I1UD,GROUP_RAIL,LCT_RAIL_BRIDGE_I1UD_G); LG(CST_RAIL_BRIDGE_O1UD,GROUP_RAIL,LCT_RAIL_BRIDGE_O1UD_G); LG(CST_RAIL_BRIDGE_I2LR,GROUP_RAIL,LCT_RAIL_BRIDGE_I2LR_G); LG(CST_RAIL_BRIDGE_O2LR,GROUP_RAIL,LCT_RAIL_BRIDGE_O2LR_G); LG(CST_RAIL_BRIDGE_I2UD,GROUP_RAIL,LCT_RAIL_BRIDGE_I2UD_G); LG(CST_RAIL_BRIDGE_O2UD,GROUP_RAIL,LCT_RAIL_BRIDGE_O2UD_G); LG(CST_ROAD_LR,GROUP_ROAD,LCT_ROAD_LR_G); LG(CST_ROAD_LU,GROUP_ROAD,LCT_ROAD_LU_G); LG(CST_ROAD_LD,GROUP_ROAD,LCT_ROAD_LD_G); LG(CST_ROAD_UD,GROUP_ROAD,LCT_ROAD_UD_G); LG(CST_ROAD_UR,GROUP_ROAD,LCT_ROAD_UR_G); LG(CST_ROAD_DR,GROUP_ROAD,LCT_ROAD_DR_G); LG(CST_ROAD_LUR,GROUP_ROAD,LCT_ROAD_LUR_G); LG(CST_ROAD_LDR,GROUP_ROAD,LCT_ROAD_LDR_G); LG(CST_ROAD_LUD,GROUP_ROAD,LCT_ROAD_LUD_G); LG(CST_ROAD_UDR,GROUP_ROAD,LCT_ROAD_UDR_G); LG(CST_ROAD_LUDR,GROUP_ROAD,LCT_ROAD_LUDR_G); LG(CST_ROAD_BRIDGE_LR,GROUP_ROAD_BRIDGE,LCT_ROAD_BRIDGE_LR_G); LG(CST_ROAD_BRIDGE_UD,GROUP_ROAD_BRIDGE,LCT_ROAD_BRIDGE_UD_G); LG(CST_ROAD_BRIDGE_LRP,GROUP_ROAD_BRIDGE,LCT_ROAD_BRIDGE_LRP_G); LG(CST_ROAD_BRIDGE_UDP,GROUP_ROAD_BRIDGE,LCT_ROAD_BRIDGE_UDP_G); LG(CST_ROAD_BRIDGE_LRPG,GROUP_ROAD_BRIDGE,LCT_ROAD_BRIDGE_LRPG_G); LG(CST_ROAD_BRIDGE_UDPG,GROUP_ROAD_BRIDGE,LCT_ROAD_BRIDGE_UDPG_G); LG(CST_ROAD_BRIDGE_I1LR,GROUP_ROAD,LCT_ROAD_BRIDGE_I1LR_G); LG(CST_ROAD_BRIDGE_O1LR,GROUP_ROAD,LCT_ROAD_BRIDGE_O1LR_G); LG(CST_ROAD_BRIDGE_I1UD,GROUP_ROAD,LCT_ROAD_BRIDGE_I1UD_G); LG(CST_ROAD_BRIDGE_O1UD,GROUP_ROAD,LCT_ROAD_BRIDGE_O1UD_G); LG(CST_ROAD_BRIDGE_I2LR,GROUP_ROAD,LCT_ROAD_BRIDGE_I2LR_G); LG(CST_ROAD_BRIDGE_O2LR,GROUP_ROAD,LCT_ROAD_BRIDGE_O2LR_G); LG(CST_ROAD_BRIDGE_I2UD,GROUP_ROAD,LCT_ROAD_BRIDGE_I2UD_G); LG(CST_ROAD_BRIDGE_O2UD,GROUP_ROAD,LCT_ROAD_BRIDGE_O2UD_G); LG(CST_TRACK_LR,GROUP_TRACK,LCT_TRACK_LR_G); LG(CST_TRACK_LU,GROUP_TRACK,LCT_TRACK_LU_G); LG(CST_TRACK_LD,GROUP_TRACK,LCT_TRACK_LD_G); LG(CST_TRACK_UD,GROUP_TRACK,LCT_TRACK_UD_G); LG(CST_TRACK_UR,GROUP_TRACK,LCT_TRACK_UR_G); LG(CST_TRACK_DR,GROUP_TRACK,LCT_TRACK_DR_G); LG(CST_TRACK_LUR,GROUP_TRACK,LCT_TRACK_LUR_G); LG(CST_TRACK_LDR,GROUP_TRACK,LCT_TRACK_LDR_G); LG(CST_TRACK_LUD,GROUP_TRACK,LCT_TRACK_LUD_G); LG(CST_TRACK_UDR,GROUP_TRACK,LCT_TRACK_UDR_G); LG(CST_TRACK_LUDR,GROUP_TRACK,LCT_TRACK_LUDR_G); LG(CST_TRACK_BRIDGE_LR,GROUP_TRACK_BRIDGE,LCT_TRACK_BRIDGE_LR_G); LG(CST_TRACK_BRIDGE_UD,GROUP_TRACK_BRIDGE,LCT_TRACK_BRIDGE_UD_G); LG(CST_TRACK_BRIDGE_LRP,GROUP_TRACK_BRIDGE,LCT_TRACK_BRIDGE_LRP_G); LG(CST_TRACK_BRIDGE_UDP,GROUP_TRACK_BRIDGE,LCT_TRACK_BRIDGE_UDP_G); LG(CST_TRACK_BRIDGE_ILR,GROUP_TRACK,LCT_TRACK_BRIDGE_ILR_G); LG(CST_TRACK_BRIDGE_OLR,GROUP_TRACK,LCT_TRACK_BRIDGE_OLR_G); LG(CST_TRACK_BRIDGE_IUD,GROUP_TRACK,LCT_TRACK_BRIDGE_IUD_G); LG(CST_TRACK_BRIDGE_OUD,GROUP_TRACK,LCT_TRACK_BRIDGE_OUD_G); LG(CST_WATER,GROUP_WATER,LCT_WATER_G); LG(CST_WATER_D,GROUP_WATER,LCT_WATER_D_G); LG(CST_WATER_R,GROUP_WATER,LCT_WATER_R_G); LG(CST_WATER_U,GROUP_WATER,LCT_WATER_U_G); LG(CST_WATER_L,GROUP_WATER,LCT_WATER_L_G); LG(CST_WATER_LR,GROUP_WATER,LCT_WATER_LR_G); LG(CST_WATER_UD,GROUP_WATER,LCT_WATER_UD_G); LG(CST_WATER_LD,GROUP_WATER,LCT_WATER_LD_G); LG(CST_WATER_RD,GROUP_WATER,LCT_WATER_RD_G); LG(CST_WATER_LU,GROUP_WATER,LCT_WATER_LU_G); LG(CST_WATER_UR,GROUP_WATER,LCT_WATER_UR_G); LG(CST_WATER_LUD,GROUP_WATER,LCT_WATER_LUD_G); LG(CST_WATER_LRD,GROUP_WATER,LCT_WATER_LRD_G); LG(CST_WATER_LUR,GROUP_WATER,LCT_WATER_LUR_G); LG(CST_WATER_URD,GROUP_WATER,LCT_WATER_URD_G); LG(CST_WATER_LURD,GROUP_WATER,LCT_WATER_LURD_G); LG(CST_WATERWELL,GROUP_WATERWELL,LCT_WATERWELL_G); LG(CST_BLACKSMITH_0,GROUP_BLACKSMITH,LCT_BLACKSMITH_0_G); LG(CST_BLACKSMITH_1,GROUP_BLACKSMITH,LCT_BLACKSMITH_1_G); LG(CST_BLACKSMITH_2,GROUP_BLACKSMITH,LCT_BLACKSMITH_2_G); LG(CST_BLACKSMITH_3,GROUP_BLACKSMITH,LCT_BLACKSMITH_3_G); LG(CST_BLACKSMITH_4,GROUP_BLACKSMITH,LCT_BLACKSMITH_4_G); LG(CST_BLACKSMITH_5,GROUP_BLACKSMITH,LCT_BLACKSMITH_5_G); LG(CST_BLACKSMITH_6,GROUP_BLACKSMITH,LCT_BLACKSMITH_6_G); LG(CST_CRICKET_1,GROUP_CRICKET,LCT_CRICKET_1_G); LG(CST_CRICKET_2,GROUP_CRICKET,LCT_CRICKET_2_G); LG(CST_CRICKET_3,GROUP_CRICKET,LCT_CRICKET_3_G); LG(CST_CRICKET_4,GROUP_CRICKET,LCT_CRICKET_4_G); LG(CST_CRICKET_5,GROUP_CRICKET,LCT_CRICKET_5_G); LG(CST_CRICKET_6,GROUP_CRICKET,LCT_CRICKET_6_G); LG(CST_CRICKET_7,GROUP_CRICKET,LCT_CRICKET_7_G); LG(CST_FIRESTATION_1,GROUP_FIRESTATION,LCT_FIRESTATION_1_G); LG(CST_FIRESTATION_2,GROUP_FIRESTATION,LCT_FIRESTATION_2_G); LG(CST_FIRESTATION_3,GROUP_FIRESTATION,LCT_FIRESTATION_3_G); LG(CST_FIRESTATION_4,GROUP_FIRESTATION,LCT_FIRESTATION_4_G); LG(CST_FIRESTATION_5,GROUP_FIRESTATION,LCT_FIRESTATION_5_G); LG(CST_FIRESTATION_6,GROUP_FIRESTATION,LCT_FIRESTATION_6_G); LG(CST_FIRESTATION_7,GROUP_FIRESTATION,LCT_FIRESTATION_7_G); LG(CST_FIRESTATION_8,GROUP_FIRESTATION,LCT_FIRESTATION_8_G); LG(CST_FIRESTATION_9,GROUP_FIRESTATION,LCT_FIRESTATION_9_G); LG(CST_FIRESTATION_10,GROUP_FIRESTATION,LCT_FIRESTATION_10_G); LG(CST_HEALTH,GROUP_HEALTH,LCT_HEALTH_G); LG(CST_MARKET_EMPTY,GROUP_MARKET,LCT_MARKET_EMPTY_G); LG(CST_MARKET_LOW,GROUP_MARKET,LCT_MARKET_LOW_G); LG(CST_MARKET_MED,GROUP_MARKET,LCT_MARKET_MED_G); LG(CST_MARKET_FULL,GROUP_MARKET,LCT_MARKET_FULL_G); LG(CST_MILL_0,GROUP_MILL,LCT_MILL_0_G); LG(CST_MILL_1,GROUP_MILL,LCT_MILL_1_G); LG(CST_MILL_2,GROUP_MILL,LCT_MILL_2_G); LG(CST_MILL_3,GROUP_MILL,LCT_MILL_3_G); LG(CST_MILL_4,GROUP_MILL,LCT_MILL_4_G); LG(CST_MILL_5,GROUP_MILL,LCT_MILL_5_G); LG(CST_MILL_6,GROUP_MILL,LCT_MILL_6_G); LG(CST_MONUMENT_0,GROUP_MONUMENT,LCT_MONUMENT_0_G); LG(CST_MONUMENT_1,GROUP_MONUMENT,LCT_MONUMENT_1_G); LG(CST_MONUMENT_2,GROUP_MONUMENT,LCT_MONUMENT_2_G); LG(CST_MONUMENT_3,GROUP_MONUMENT,LCT_MONUMENT_3_G); LG(CST_MONUMENT_4,GROUP_MONUMENT,LCT_MONUMENT_4_G); LG(CST_MONUMENT_5,GROUP_MONUMENT,LCT_MONUMENT_5_G); LG(CST_POTTERY_0,GROUP_POTTERY,LCT_POTTERY_0_G); LG(CST_POTTERY_1,GROUP_POTTERY,LCT_POTTERY_1_G); LG(CST_POTTERY_2,GROUP_POTTERY,LCT_POTTERY_2_G); LG(CST_POTTERY_3,GROUP_POTTERY,LCT_POTTERY_3_G); LG(CST_POTTERY_4,GROUP_POTTERY,LCT_POTTERY_4_G); LG(CST_POTTERY_5,GROUP_POTTERY,LCT_POTTERY_5_G); LG(CST_POTTERY_6,GROUP_POTTERY,LCT_POTTERY_6_G); LG(CST_POTTERY_7,GROUP_POTTERY,LCT_POTTERY_7_G); LG(CST_POTTERY_8,GROUP_POTTERY,LCT_POTTERY_8_G); LG(CST_POTTERY_9,GROUP_POTTERY,LCT_POTTERY_9_G); LG(CST_POTTERY_10,GROUP_POTTERY,LCT_POTTERY_10_G); LG(CST_RECYCLE,GROUP_RECYCLE,LCT_RECYCLE_G); LG(CST_SCHOOL,GROUP_SCHOOL,LCT_SCHOOL_G); LG(CST_SHANTY,GROUP_SHANTY,LCT_SHANTY_G); LG(CST_SUBSTATION_R,GROUP_SUBSTATION,LCT_SUBSTATION_R_G); LG(CST_SUBSTATION_G,GROUP_SUBSTATION,LCT_SUBSTATION_G_G); LG(CST_SUBSTATION_RG,GROUP_SUBSTATION,LCT_SUBSTATION_RG_G); LG(CST_WINDMILL_1_G,GROUP_WIND_POWER,LCT_WINDMILL_1_G_G); LG(CST_WINDMILL_2_G,GROUP_WIND_POWER,LCT_WINDMILL_2_G_G); LG(CST_WINDMILL_3_G,GROUP_WIND_POWER,LCT_WINDMILL_3_G_G); LG(CST_WINDMILL_1_RG,GROUP_WIND_POWER,LCT_WINDMILL_1_RG_G); LG(CST_WINDMILL_2_RG,GROUP_WIND_POWER,LCT_WINDMILL_2_RG_G); LG(CST_WINDMILL_3_RG,GROUP_WIND_POWER,LCT_WINDMILL_3_RG_G); LG(CST_WINDMILL_1_R,GROUP_WIND_POWER,LCT_WINDMILL_1_R_G); LG(CST_WINDMILL_2_R,GROUP_WIND_POWER,LCT_WINDMILL_2_R_G); LG(CST_WINDMILL_3_R,GROUP_WIND_POWER,LCT_WINDMILL_3_R_G); LG(CST_WINDMILL_1_W,GROUP_WINDMILL,LCT_WINDMILL_1_W_G); LG(CST_WINDMILL_2_W,GROUP_WINDMILL,LCT_WINDMILL_2_W_G); LG(CST_WINDMILL_3_W,GROUP_WINDMILL,LCT_WINDMILL_3_W_G); LG(CST_INDUSTRY_L_C,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_C_G); LG(CST_INDUSTRY_L_Q1,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_Q1_G); LG(CST_INDUSTRY_L_Q2,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_Q2_G); LG(CST_INDUSTRY_L_Q3,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_Q3_G); LG(CST_INDUSTRY_L_Q4,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_Q4_G); LG(CST_INDUSTRY_L_L1,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_L1_G); LG(CST_INDUSTRY_L_L2,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_L2_G); LG(CST_INDUSTRY_L_L3,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_L3_G); LG(CST_INDUSTRY_L_L4,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_L4_G); LG(CST_INDUSTRY_L_M1,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_M1_G); LG(CST_INDUSTRY_L_M2,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_M2_G); LG(CST_INDUSTRY_L_M3,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_M3_G); LG(CST_INDUSTRY_L_M4,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_M4_G); LG(CST_INDUSTRY_L_H1,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_H1_G); LG(CST_INDUSTRY_L_H2,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_H2_G); LG(CST_INDUSTRY_L_H3,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_H3_G); LG(CST_INDUSTRY_L_H4,GROUP_INDUSTRY_L,LCT_INDUSTRY_L_H4_G); LG(CST_RESIDENCE_LL,GROUP_RESIDENCE_LL,LCT_RESIDENCE_LL_G); LG(CST_RESIDENCE_ML,GROUP_RESIDENCE_ML,LCT_RESIDENCE_ML_G); LG(CST_RESIDENCE_HL,GROUP_RESIDENCE_HL,LCT_RESIDENCE_HL_G); LG(CST_RESIDENCE_LH,GROUP_RESIDENCE_LH,LCT_RESIDENCE_LH_G); LG(CST_RESIDENCE_MH,GROUP_RESIDENCE_MH,LCT_RESIDENCE_MH_G); LG(CST_RESIDENCE_HH,GROUP_RESIDENCE_HH,LCT_RESIDENCE_HH_G); LG(CST_UNIVERSITY,GROUP_UNIVERSITY,LCT_UNIVERSITY_G); LG(CST_COALMINE_EMPTY,GROUP_COALMINE,LCT_COALMINE_EMPTY_G); LG(CST_COALMINE_LOW,GROUP_COALMINE,LCT_COALMINE_LOW_G); LG(CST_COALMINE_MED,GROUP_COALMINE,LCT_COALMINE_MED_G); LG(CST_COALMINE_FULL,GROUP_COALMINE,LCT_COALMINE_FULL_G); LG(CST_COMMUNE_1,GROUP_COMMUNE,LCT_COMMUNE_1_G); LG(CST_COMMUNE_2,GROUP_COMMUNE,LCT_COMMUNE_2_G); LG(CST_COMMUNE_3,GROUP_COMMUNE,LCT_COMMUNE_3_G); LG(CST_COMMUNE_4,GROUP_COMMUNE,LCT_COMMUNE_4_G); LG(CST_COMMUNE_5,GROUP_COMMUNE,LCT_COMMUNE_5_G); LG(CST_COMMUNE_6,GROUP_COMMUNE,LCT_COMMUNE_6_G); LG(CST_COMMUNE_7,GROUP_COMMUNE,LCT_COMMUNE_7_G); LG(CST_COMMUNE_8,GROUP_COMMUNE,LCT_COMMUNE_8_G); LG(CST_COMMUNE_9,GROUP_COMMUNE,LCT_COMMUNE_9_G); LG(CST_COMMUNE_10,GROUP_COMMUNE,LCT_COMMUNE_10_G); LG(CST_COMMUNE_11,GROUP_COMMUNE,LCT_COMMUNE_11_G); LG(CST_COMMUNE_12,GROUP_COMMUNE,LCT_COMMUNE_12_G); LG(CST_COMMUNE_13,GROUP_COMMUNE,LCT_COMMUNE_13_G); LG(CST_COMMUNE_14,GROUP_COMMUNE,LCT_COMMUNE_14_G); LG(CST_EX_PORT,GROUP_PORT,LCT_EX_PORT_G); LG(CST_FARM_O0,GROUP_ORGANIC_FARM,LCT_FARM_O0_G); LG(CST_FARM_O1,GROUP_ORGANIC_FARM,LCT_FARM_O1_G); LG(CST_FARM_O2,GROUP_ORGANIC_FARM,LCT_FARM_O2_G); LG(CST_FARM_O3,GROUP_ORGANIC_FARM,LCT_FARM_O3_G); LG(CST_FARM_O4,GROUP_ORGANIC_FARM,LCT_FARM_O4_G); LG(CST_FARM_O5,GROUP_ORGANIC_FARM,LCT_FARM_O5_G); LG(CST_FARM_O6,GROUP_ORGANIC_FARM,LCT_FARM_O6_G); LG(CST_FARM_O7,GROUP_ORGANIC_FARM,LCT_FARM_O7_G); LG(CST_FARM_O8,GROUP_ORGANIC_FARM,LCT_FARM_O8_G); LG(CST_FARM_O9,GROUP_ORGANIC_FARM,LCT_FARM_O9_G); LG(CST_FARM_O10,GROUP_ORGANIC_FARM,LCT_FARM_O10_G); LG(CST_FARM_O11,GROUP_ORGANIC_FARM,LCT_FARM_O11_G); LG(CST_FARM_O12,GROUP_ORGANIC_FARM,LCT_FARM_O12_G); LG(CST_FARM_O13,GROUP_ORGANIC_FARM,LCT_FARM_O13_G); LG(CST_FARM_O14,GROUP_ORGANIC_FARM,LCT_FARM_O14_G); LG(CST_FARM_O15,GROUP_ORGANIC_FARM,LCT_FARM_O15_G); LG(CST_FARM_O16,GROUP_ORGANIC_FARM,LCT_FARM_O16_G); LG(CST_INDUSTRY_H_C,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_C_G); LG(CST_INDUSTRY_H_L1,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L1_G); LG(CST_INDUSTRY_H_L2,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L2_G); LG(CST_INDUSTRY_H_L3,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L3_G); LG(CST_INDUSTRY_H_L4,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L4_G); LG(CST_INDUSTRY_H_L5,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L5_G); LG(CST_INDUSTRY_H_L6,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L6_G); LG(CST_INDUSTRY_H_L7,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L7_G); LG(CST_INDUSTRY_H_L8,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_L8_G); LG(CST_INDUSTRY_H_M1,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M1_G); LG(CST_INDUSTRY_H_M2,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M2_G); LG(CST_INDUSTRY_H_M3,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M3_G); LG(CST_INDUSTRY_H_M4,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M4_G); LG(CST_INDUSTRY_H_M5,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M5_G); LG(CST_INDUSTRY_H_M6,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M6_G); LG(CST_INDUSTRY_H_M7,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M7_G); LG(CST_INDUSTRY_H_M8,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_M8_G); LG(CST_INDUSTRY_H_H1,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H1_G); LG(CST_INDUSTRY_H_H2,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H2_G); LG(CST_INDUSTRY_H_H3,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H3_G); LG(CST_INDUSTRY_H_H4,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H4_G); LG(CST_INDUSTRY_H_H5,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H5_G); LG(CST_INDUSTRY_H_H6,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H6_G); LG(CST_INDUSTRY_H_H7,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H7_G); LG(CST_INDUSTRY_H_H8,GROUP_INDUSTRY_H,LCT_INDUSTRY_H_H8_G); LG(CST_OREMINE_1,GROUP_OREMINE,LCT_OREMINE_1_G); LG(CST_OREMINE_2,GROUP_OREMINE,LCT_OREMINE_2_G); LG(CST_OREMINE_3,GROUP_OREMINE,LCT_OREMINE_3_G); LG(CST_OREMINE_4,GROUP_OREMINE,LCT_OREMINE_4_G); LG(CST_OREMINE_5,GROUP_OREMINE,LCT_OREMINE_5_G); LG(CST_OREMINE_6,GROUP_OREMINE,LCT_OREMINE_6_G); LG(CST_OREMINE_7,GROUP_OREMINE,LCT_OREMINE_7_G); LG(CST_OREMINE_8,GROUP_OREMINE,LCT_OREMINE_8_G); LG(CST_POWERS_COAL_EMPTY,GROUP_COAL_POWER,LCT_POWERS_COAL_EMPTY_G); LG(CST_POWERS_COAL_LOW,GROUP_COAL_POWER,LCT_POWERS_COAL_LOW_G); LG(CST_POWERS_COAL_MED,GROUP_COAL_POWER,LCT_POWERS_COAL_MED_G); LG(CST_POWERS_COAL_FULL,GROUP_COAL_POWER,LCT_POWERS_COAL_FULL_G); LG(CST_POWERS_SOLAR,GROUP_SOLAR_POWER,LCT_POWERS_SOLAR_G); LG(CST_ROCKET_1,GROUP_ROCKET,LCT_ROCKET_1_G); LG(CST_ROCKET_2,GROUP_ROCKET,LCT_ROCKET_2_G); LG(CST_ROCKET_3,GROUP_ROCKET,LCT_ROCKET_3_G); LG(CST_ROCKET_4,GROUP_ROCKET,LCT_ROCKET_4_G); LG(CST_ROCKET_5,GROUP_ROCKET,LCT_ROCKET_5_G); LG(CST_ROCKET_6,GROUP_ROCKET,LCT_ROCKET_6_G); LG(CST_ROCKET_7,GROUP_ROCKET,LCT_ROCKET_7_G); LG(CST_ROCKET_FLOWN,GROUP_ROCKET,LCT_ROCKET_FLOWN_G); LG(CST_TIP_0,GROUP_TIP,LCT_TIP_0_G); LG(CST_TIP_1,GROUP_TIP,LCT_TIP_1_G); LG(CST_TIP_2,GROUP_TIP,LCT_TIP_2_G); LG(CST_TIP_3,GROUP_TIP,LCT_TIP_3_G); LG(CST_TIP_4,GROUP_TIP,LCT_TIP_4_G); LG(CST_TIP_5,GROUP_TIP,LCT_TIP_5_G); LG(CST_TIP_6,GROUP_TIP,LCT_TIP_6_G); LG(CST_TIP_7,GROUP_TIP,LCT_TIP_7_G); LG(CST_TIP_8,GROUP_TIP,LCT_TIP_8_G); LG(CST_DESERT,GROUP_DESERT,LCT_DESERT_G); LG(CST_DESERT_0,GROUP_DESERT,LCT_DESERT_0_G); LG(CST_DESERT_1D,GROUP_DESERT,LCT_DESERT_1D_G); LG(CST_DESERT_1L,GROUP_DESERT,LCT_DESERT_1L_G); LG(CST_DESERT_1R,GROUP_DESERT,LCT_DESERT_1R_G); LG(CST_DESERT_1U,GROUP_DESERT,LCT_DESERT_1U_G); LG(CST_DESERT_2LD,GROUP_DESERT,LCT_DESERT_2LD_G); LG(CST_DESERT_2LR,GROUP_DESERT,LCT_DESERT_2LR_G); LG(CST_DESERT_2LU,GROUP_DESERT,LCT_DESERT_2LU_G); LG(CST_DESERT_2RD,GROUP_DESERT,LCT_DESERT_2RD_G); LG(CST_DESERT_2RU,GROUP_DESERT,LCT_DESERT_2RU_G); LG(CST_DESERT_2UD,GROUP_DESERT,LCT_DESERT_2UD_G); LG(CST_DESERT_3LRD,GROUP_DESERT,LCT_DESERT_3LRD_G); LG(CST_DESERT_3LRU,GROUP_DESERT,LCT_DESERT_3LRU_G); LG(CST_DESERT_3LUD,GROUP_DESERT,LCT_DESERT_3LUD_G); LG(CST_DESERT_3RUD,GROUP_DESERT,LCT_DESERT_3RUD_G); LG(CST_TREE,GROUP_TREE,LCT_TREE_G); LG(CST_TREE2,GROUP_TREE2,LCT_TREE2_G); LG(CST_TREE3,GROUP_TREE3,LCT_TREE3_G); return 0; }