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