Exemple #1
0
void
mainwin_destroy(MainWin *mw)
{
	if(mw->tooltip)
		tooltip_destroy(mw->tooltip);
	
	if(! mw->no_free_color)
		XFreeColors(mw->dpy, mw->colormap, mw->pixels, 2, 0);
	else {
		if(! (mw->no_free_color & 1))
			XFreeColors(mw->dpy, mw->colormap, &BORDER_COLOR(mw), 1, 0);
		if(! (mw->no_free_color & 2))
			XFreeColors(mw->dpy, mw->colormap, &HIGHLIGHT_COLOR(mw), 1, 0);
	}
	
	if(mw->cm_highlight)
	{
		imlib_context_set_color_modifier(mw->cm_highlight);
		imlib_free_color_modifier();
	}
	
	if(mw->cm_normal)
	{
		imlib_context_set_color_modifier(mw->cm_normal);
		imlib_free_color_modifier();
	}
	
	if(mw->background)
	{
		imlib_context_set_image(mw->background);
		imlib_free_image();
	}
	
	if(mw->bg_pixmap != None)
		imlib_free_pixmap_and_mask(mw->bg_pixmap);
	
	XDestroyWindow(mw->dpy, mw->window);
	
#ifdef XINERAMA
	if(mw->xin_info)
		XFree(mw->xin_info);
#endif /* XINERAMA */
	
	free(mw);
}
/** The ColorMap constructor defines many hardcoded RGB values that are used during segmentation. The most important of these with respect to inputs
  * are the STEM_COLOR, BORDER_COLOR, UNSEGMENTED_COLOR. The remainders correspond to leaves. If a hand-segmented or machine learning segmented plant
  * is provided and colors don't correspond to these values, behavior will likely be unexpected.
  */
ColorMap::ColorMap() {

    TupleTriplet STEM_COLOR(0.0, 255.0, 255.0);
    TupleTriplet BORDER_COLOR(80.0, 80.0, 80.0);
    TupleTriplet UNSEGMENTED_COLOR(255.0, 255.0, 255.0);
    TupleTriplet DEBUG_COLOR(255.0, 20.0, 147.0);
    TupleTriplet INFLORESCENCE_COLOR(255.0, 215.0, 0.0); // gold

    _stem_color = STEM_COLOR;
    _border_color = BORDER_COLOR;
    _unsegmented_color = UNSEGMENTED_COLOR;
    _debug_color = DEBUG_COLOR;
    _inflorescence_color = INFLORESCENCE_COLOR;

    // We're emulating the ggplot2 colors.
    // http://stackoverflow.com/questions/8197559/emulate-ggplot2-default-color-palette
    // and converted the hex to rgb
    TupleTriplet color1(248.0, 118.0, 109.0); //salmon-y #F8766D
    TupleTriplet color2(183.0, 159.0, 0.0); //tan-y #B79F00
    TupleTriplet color3(0.0, 186.0, 56.0); //green-y #00BA38
    //TupleTriplet color4(0.0, 191.0, 196.0); //sea-green-y #00BFC4
    TupleTriplet color4(0.0, 134.0, 125.0); //sea-green-y
    TupleTriplet color5(97.0, 156.0, 255.0); // sky blue-y #619CFF
    TupleTriplet color6(245.0, 100.0, 227.0); // pink-y #F564E3
    TupleTriplet color7(229.0, 135.0, 0.0); //orange-y #E58700
    TupleTriplet color8(185.0, 131.0, 255.0); // purple-y #B983FF

    TupleTriplet color9(222.0, 42.0, 29.0); // red-ish
    TupleTriplet color10(222.0, 29.0, 186.0);
    TupleTriplet color11(103.0, 29.0, 222.0);
    TupleTriplet color12(20.0, 42.0, 222.0);
    /*
    TupleTriplet color5(29.0, 135.0, 222.0);
    TupleTriplet color6(29.0, 222.0, 96.0);
    TupleTriplet color7(148.0, 222.0, 29.0);
    TupleTriplet color8(222.0, 125.0, 29.0);
    TupleTriplet color9(240.0, 178.0, 179.0);
    TupleTriplet color10(176.0, 237.0, 161.0);
    TupleTriplet color11(250.0, 250.0, 17.0);
    TupleTriplet color12(247.0, 168.0, 229.0);
    */
    //New colors added to account for manual segmentation
    TupleTriplet color13(150.0, 150.0, 150.0);
    TupleTriplet color14(0.0, 0.0, 255.0);
    TupleTriplet color15(170.0, 170.0, 255.0);
    TupleTriplet color16(255.0, 0.0, 0.0);
    TupleTriplet color17(255.0, 0.0, 127.0);
    TupleTriplet color18(0.0, 170.0, 0.0);
    TupleTriplet color19(85.0, 170.0, 255.0);
    TupleTriplet color20(255.0, 170.0, 0.0);
    TupleTriplet color21(153.0, 102.0, 51.0);
    TupleTriplet color22(255.0, 170.0, 255.0);
    TupleTriplet color23(170.0, 255.0, 127.0);
    TupleTriplet color24(255.0, 255.0, 127.0);
    TupleTriplet color25(108.0, 108.0, 108.0);
    TupleTriplet color26(237.0, 146.0, 15.0);
    TupleTriplet color27(170.0, 255.0, 0.0);

    _leafColorMap.insert(std::pair<int, TupleTriplet> (1, color1));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (2, color2));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (3, color3));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (4, color4));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (5, color5));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (6, color6));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (7, color7));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (8, color8));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (9, color9));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (10, color10));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (11, color11));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (12, color12));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (13, color13));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (14, color14));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (15, color15));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (16, color16));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (17, color17));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (18, color18));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (19, color19));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (20, color20));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (21, color21));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (22, color22));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (23, color23));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (24, color24));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (25, color25));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (26, color26));
    _leafColorMap.insert(std::pair<int, TupleTriplet> (27, color27));


    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color1, 1));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color2, 2));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color3, 3));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color4, 4));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color5, 5));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color6, 6));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color7, 7));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color8, 8));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color9, 9));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color10, 10));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color11, 11));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color12, 12));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color13, 13));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color14, 14));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color15, 15));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color16, 16));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color17, 17));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color18, 18));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color19, 19));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color20, 20));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color21, 21));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color22, 22));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color23, 23));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color24, 24));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color25, 25));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color26, 26));
    _leafColorMap_colorsToLabel.insert(std::pair<TupleTriplet, int> (color27, 27));

    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color1, 1));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color2, 2));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color3, 3));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color4, 4));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color5, 5));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color6, 6));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color7, 7));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color8, 8));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color9, 9));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color10, 10));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color11, 11));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color12, 12));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color13, 13));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color14, 14));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color15, 15));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color16, 16));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color17, 17));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color18, 18));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color19, 19));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color20, 20));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color21, 21));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color22, 22));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color23, 23));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color24, 24));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color25, 25));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color26, 26));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (color27, 27));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (STEM_COLOR, 28));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (BORDER_COLOR, 29));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (UNSEGMENTED_COLOR, 30));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (DEBUG_COLOR, 31));
    _map_explicitlyHandledColors.insert(std::pair<TupleTriplet, int> (INFLORESCENCE_COLOR, 32));

}
Exemple #3
0
MainWin *
mainwin_create(Display *dpy, dlist *config)
{
	const char *tmp;
	XColor screen_color, exact_color;
	XSetWindowAttributes wattr;
	XWindowAttributes rootattr;
	unsigned long valuemask = CWEventMask;
#ifdef XINERAMA
	int event_base, error_base;
#endif /* XINERAMA */
	
	MainWin *mw = (MainWin *)malloc(sizeof(MainWin));
	
	mw->screen = DefaultScreen(dpy);
	mw->visual = imlib_get_best_visual(dpy, mw->screen, &mw->depth);
	mw->colormap = DefaultColormap(dpy, mw->screen);
	mw->root = RootWindow(dpy, mw->screen);
	mw->background = 0;
	mw->bg_pixmap = None;
#ifdef XINERAMA
	mw->xin_info = mw->xin_active = 0;
	mw->xin_screens = 0;
#endif /* XINERAMA */
	mw->x = mw->y = 0;
	
	mw->no_free_color = 0;
	mw->pressed = mw->focus = 0;
	mw->tooltip = 0;
	mw->cod = 0;
	mw->cm_normal = mw->cm_highlight = 0;
	mw->key_up = XKeysymToKeycode(dpy, XK_Up);
	mw->key_down = XKeysymToKeycode(dpy, XK_Down);
	mw->key_left = XKeysymToKeycode(dpy, XK_Left);
	mw->key_right = XKeysymToKeycode(dpy, XK_Right);
	mw->key_enter = XKeysymToKeycode(dpy, XK_Return);
	mw->key_space = XKeysymToKeycode(dpy, XK_space);
	mw->key_escape = XKeysymToKeycode(dpy, XK_Escape);
	mw->key_q = XKeysymToKeycode(dpy, XK_q);
	
	XGetWindowAttributes(dpy, mw->root, &rootattr);
	mw->width = rootattr.width;
	mw->height = rootattr.height;
	
	mw->dpy = dpy;
	
	valuemask |= CWBackPixel;
	wattr.background_pixel = BlackPixel(dpy, mw->screen);
	
	wattr.event_mask = VisibilityChangeMask |
	                   ButtonReleaseMask;
	
	mw->window = XCreateWindow(dpy, mw->root, 0, 0, mw->width, mw->height, 0,
	                           CopyFromParent, InputOutput, CopyFromParent,
	                           valuemask, &wattr);
	if(mw->window == None) {
		free(mw);
		return 0;
	}

#ifdef XINERAMA
# ifdef DEBUG
	fprintf(stderr, "--> checking for Xinerama extension... ");
# endif /* DEBUG */
	if(XineramaQueryExtension(dpy, &event_base, &error_base))
	{
# ifdef DEBUG
	    fprintf(stderr, "yes\n--> checking if Xinerama is enabled... ");
# endif /* DEBUG */
	    if(XineramaIsActive(dpy))
	    {
# ifdef DEBUG
	        fprintf(stderr, "yes\n--> fetching Xinerama info... ");
# endif /* DEBUG */
	        mw->xin_info = XineramaQueryScreens(mw->dpy, &mw->xin_screens);
# ifdef DEBUG	        
		fprintf(stderr, "done (%i screens)\n", mw->xin_screens);
# endif /* DEBUG */
	    }
# ifdef DEBUG
	    else
	        fprintf(stderr, "no\n");
# endif /* DEBUG */
	}
# ifdef DEBUG
	else
	    fprintf(stderr, "no\n");
# endif /* DEBUG */
#endif /* XINERAMA */
	
	tmp = config_get(config, "normal", "border", "black");
	if(! XAllocNamedColor(mw->dpy, mw->colormap, tmp, &screen_color, &exact_color))
	{
		fprintf(stderr, "WARNING: Invalid color '%s', reverting to black.\n", tmp);
		BORDER_COLOR(mw) = BlackPixel(mw->dpy, mw->screen);
		mw->no_free_color = 1;
	} else
		BORDER_COLOR(mw) = screen_color.pixel;
	
	tmp = config_get(config, "highlight", "border", "#d0d0ff");
	if(! XAllocNamedColor(mw->dpy, mw->colormap, tmp, &screen_color, &exact_color))
	{
		fprintf(stderr, "WARNING: Invalid color '%s', reverting to white.\n", tmp);
		HIGHLIGHT_COLOR(mw) = WhitePixel(mw->dpy, mw->screen);
		mw->no_free_color |= 2;
	} else
		HIGHLIGHT_COLOR(mw) = screen_color.pixel;
	
	tmp = config_get(config, "general", "distance", "50");
	DISTANCE(mw) = MAX(1, strtol(tmp, 0, 10));
	
	if(! strcasecmp(config_get(config, "tooltip", "show", "true"), "true"))
		mw->tooltip = tooltip_create(mw, config);
	
	mw->cm_normal = create_modifier(mw, config, "normal", "0.0", "white", "200");
	mw->cm_highlight = create_modifier(mw, config, "highlight", "0.05", "#d0d0ff", "255");
	
	return mw;
}