src/common/imagfill.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/imagfill.cpp
// Purpose:     FloodFill for wxImage
// Author:      Julian Smart
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////


// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_IMAGE && !defined(__WXMSW__)
// we have no use for this code in wxMSW...

#ifndef WX_PRECOMP
    #include "wx/brush.h"
    #include "wx/dc.h"
    #include "wx/dcmemory.h"
    #include "wx/image.h"
#endif

// DoFloodFill
// Fills with the colour extracted from fillBrush, starting at x,y until either
// a color different from the start pixel is reached (wxFLOOD_SURFACE)
// or fill color is reached (wxFLOOD_BORDER)

static bool LINKAGEMODE MatchPixel(wxImage *img, int x, int y, int w, int h, const wxColour& c)
{
    if ((x<0)||(x>=w)||(y<0)||(y>=h)) return false;

    unsigned char r = img->GetRed(x,y);
    unsigned char g = img->GetGreen(x,y);
    unsigned char b = img->GetBlue(x,y);
    return c.Red() == r && c.Green() == g && c.Blue() == b ;
}

static bool LINKAGEMODE MatchBoundaryPixel(wxImage *img, int x, int y, int w, int h, const wxColour & fill, const wxColour& bound)
{
    if ((x<0)||(x>=w)||(y<0)||(y>=h)) return true;

    unsigned char r = img->GetRed(x,y);
    unsigned char g = img->GetGreen(x,y);
    unsigned char b = img->GetBlue(x,y);
    if ( fill.Red() == r && fill.Green() == g && fill.Blue() == b )
        return true;
    if ( bound.Red() == r && bound.Green() == g && bound.Blue() == b )
        return true;
    return false;
}


static void LINKAGEMODE
wxImageFloodFill(wxImage *image,
                 wxCoord x, wxCoord y, const wxBrush & fillBrush,
                 const wxColour& testColour, int style)
{
    /* A diamond flood-fill using a circular queue system.
    Each pixel surrounding the current pixel is added to
    the queue if it meets the criteria, then is retrieved in
    its turn.  Code originally based on http://www.drawit.co.nz/Developers.htm,
    with explicit permission to use this for wxWidgets granted by Andrew Empson
    (no copyright claimed)
     */

    int width = image->GetWidth();
    int height = image->GetHeight();

    //Draw using a pen made from the current brush colour
    //Potentially allows us to use patterned flood fills in future code
    wxColour fillColour = fillBrush.GetColour();
    unsigned char r = fillColour.Red();
    unsigned char g = fillColour.Green();
    unsigned char b = fillColour.Blue();

    //initial test :
    if (style == wxFLOOD_SURFACE)
    {
       //if wxFLOOD_SURFACE, if fill colour is same as required, we don't do anything
       if (     image->GetRed(x,y)   != r
             || image->GetGreen(x,y) != g
             || image->GetBlue (x,y) != b   )
        {
        //prepare memory for queue
        //queue save, start, read
        size_t *qs, *qst, *qr;

        //queue size (physical)
        long qSz= height * width * 2;
        qst = new size_t [qSz];

        //temporary x and y locations
        int xt, yt;

        for (int i=0; i < qSz; i++)
            qst[i] = 0;

        // start queue
        qs=qr=qst;
        *qs=xt=x;
        qs++;
        *qs=yt=y;
        qs++;

        image->SetRGB(xt,yt,r,g,b);

        //Main queue loop
        while(qr!=qs)
        {
            //Add new members to queue
            //Above current pixel
            if(MatchPixel(image,xt,yt-1,width,height,testColour))
            {
                *qs=xt;
                qs++;
                *qs=yt-1;
                qs++;
                image->SetRGB(xt,yt-1,r,g,b);

                //Loop back to beginning of queue
                if(qs>=(qst+qSz)) qs=qst;
            }

            //Below current pixel
            if(MatchPixel(image,xt,yt+1,width,height,testColour))
            {
                *qs=xt;
                qs++;
                *qs=yt+1;
                qs++;
                image->SetRGB(xt,yt+1,r,g,b);
                if(qs>=(qst+qSz)) qs=qst;
            }

            //Left of current pixel
            if(MatchPixel(image,xt-1,yt,width,height,testColour))
            {
                *qs=xt-1;
                qs++;
                *qs=yt;
                qs++;
                image->SetRGB(xt-1,yt,r,g,b);
                if(qs>=(qst+qSz)) qs=qst;
            }

            //Right of current pixel
            if(MatchPixel(image,xt+1,yt,width,height,testColour))
            {
                *qs=xt+1;
                qs++;
                *qs=yt;
                qs++;
                image->SetRGB(xt+1,yt,r,g,b);
                if(qs>=(qst+qSz)) qs=qst;
            }

            //Retrieve current queue member
            qr+=2;

            //Loop back to the beginning
            if(qr>=(qst+qSz)) qr=qst;
            xt=*qr;
            yt=*(qr+1);

        //Go Back to beginning of loop
        }

        delete[] qst;
        }
    }
    else
    {
    //style is wxFLOOD_BORDER
    // fill up to testColor border - if already testColour don't do anything
    if (  image->GetRed(x,y)   != testColour.Red()
          || image->GetGreen(x,y) != testColour.Green()
          || image->GetBlue(x,y)  != testColour.Blue() )
    {
        //prepare memory for queue
        //queue save, start, read
        size_t *qs, *qst, *qr;

        //queue size (physical)
        long qSz= height * width * 2;
        qst = new size_t [qSz];

        //temporary x and y locations
        int xt, yt;

        for (int i=0; i < qSz; i++)
            qst[i] = 0;

        // start queue
        qs=qr=qst;
        *qs=xt=x;
        qs++;
        *qs=yt=y;
        qs++;

        image->SetRGB(xt,yt,r,g,b);

        //Main queue loop
        while (qr!=qs)
        {
            //Add new members to queue
            //Above current pixel
            if(!MatchBoundaryPixel(image,xt,yt-1,width,height,fillColour,testColour))
            {
                *qs=xt;
                qs++;
                *qs=yt-1;
                qs++;
                image->SetRGB(xt,yt-1,r,g,b);

                //Loop back to beginning of queue
                if(qs>=(qst+qSz)) qs=qst;
            }

            //Below current pixel
            if(!MatchBoundaryPixel(image,xt,yt+1,width,height,fillColour,testColour))
            {
                *qs=xt;
                qs++;
                *qs=yt+1;
                qs++;
                image->SetRGB(xt,yt+1,r,g,b);
                if(qs>=(qst+qSz)) qs=qst;
            }

            //Left of current pixel
            if(!MatchBoundaryPixel(image,xt-1,yt,width,height,fillColour,testColour))
            {
                *qs=xt-1;
                qs++;
                *qs=yt;
                qs++;
                image->SetRGB(xt-1,yt,r,g,b);
                if(qs>=(qst+qSz)) qs=qst;
            }

            //Right of current pixel
            if(!MatchBoundaryPixel(image,xt+1,yt,width,height,fillColour,testColour))
            {
                *qs=xt+1;
                qs++;
                *qs=yt;
                qs++;
                image->SetRGB(xt+1,yt,r,g,b);
                if(qs>=(qst+qSz)) qs=qst;
            }

            //Retrieve current queue member
            qr+=2;

            //Loop back to the beginning
            if(qr>=(qst+qSz)) qr=qst;
            xt=*qr;
            yt=*(qr+1);

        //Go Back to beginning of loop
        }

        delete[] qst;
        }
    }
    //all done,
}


bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
                   const wxColour& col, wxFloodFillStyle style)
{
    if (dc->GetBrush().IsTransparent())
        return true;

    int height = 0;
    int width  = 0;
    dc->GetSize(&width, &height);

    //it would be nice to fail if we don't get a sensible size...
    wxCHECK_MSG(width >= 1 && height >= 1, false,
                wxT("In FloodFill, dc.GetSize routine failed, method not supported by this DC"));

    const int x_dev = dc->LogicalToDeviceX(x);
    const int y_dev = dc->LogicalToDeviceY(y);

    // if start point is outside dc, can't do anything
    if (!wxRect(0, 0, width, height).Contains(x_dev, y_dev))
        return false;

    wxBitmap bitmap(width, height);
    wxMemoryDC memdc(bitmap);
    // match dc scales
    double sx, sy;
    dc->GetUserScale(&sx, &sy);
    memdc.SetUserScale(sx, sy);
    dc->GetLogicalScale(&sx, &sy);
    memdc.SetLogicalScale(sx, sy);

    // get logical size and origin
    const int w_log = dc->DeviceToLogicalXRel(width);
    const int h_log = dc->DeviceToLogicalYRel(height);
    const int x0_log = dc->DeviceToLogicalX(0);
    const int y0_log = dc->DeviceToLogicalY(0);

    memdc.Blit(0, 0, w_log, h_log, dc, x0_log, y0_log);
    memdc.SelectObject(wxNullBitmap);

    wxImage image = bitmap.ConvertToImage();
    wxImageFloodFill(&image, x_dev, y_dev, dc->GetBrush(), col, style);
    bitmap = wxBitmap(image);
    memdc.SelectObject(bitmap);
    dc->Blit(x0_log, y0_log, w_log, h_log, &memdc, 0, 0);

    return true;
}

#endif // wxUSE_IMAGE
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/imagfill.cpp
	3	// Purpose: FloodFill for wxImage
	4	// Author: Julian Smart
	5	// RCS-ID: $Id$
	6	// Copyright: (c) Julian Smart
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10
	11	// For compilers that support precompilation, includes "wx.h".
	12	#include "wx/wxprec.h"
	13
	14	#ifdef __BORLANDC__
	15	#pragma hdrstop
	16	#endif
	17
	18	#if wxUSE_IMAGE && !defined(__WXMSW__)
	19	// we have no use for this code in wxMSW...
	20
	21	#ifndef WX_PRECOMP
	22	#include "wx/brush.h"
	23	#include "wx/dc.h"
	24	#include "wx/dcmemory.h"
	25	#include "wx/image.h"
	26	#endif
	27
	28	// DoFloodFill
	29	// Fills with the colour extracted from fillBrush, starting at x,y until either
	30	// a color different from the start pixel is reached (wxFLOOD_SURFACE)
	31	// or fill color is reached (wxFLOOD_BORDER)
	32
	33	static bool LINKAGEMODE MatchPixel(wxImage *img, int x, int y, int w, int h, const wxColour& c)
	34	{
	35	if ((x<0)\|\|(x>=w)\|\|(y<0)\|\|(y>=h)) return false;
	36
	37	unsigned char r = img->GetRed(x,y);
	38	unsigned char g = img->GetGreen(x,y);
	39	unsigned char b = img->GetBlue(x,y);
	40	return c.Red() == r && c.Green() == g && c.Blue() == b ;
	41	}
	42
	43	static bool LINKAGEMODE MatchBoundaryPixel(wxImage *img, int x, int y, int w, int h, const wxColour & fill, const wxColour& bound)
	44	{
	45	if ((x<0)\|\|(x>=w)\|\|(y<0)\|\|(y>=h)) return true;
	46
	47	unsigned char r = img->GetRed(x,y);
	48	unsigned char g = img->GetGreen(x,y);
	49	unsigned char b = img->GetBlue(x,y);
	50	if ( fill.Red() == r && fill.Green() == g && fill.Blue() == b )
	51	return true;
	52	if ( bound.Red() == r && bound.Green() == g && bound.Blue() == b )
	53	return true;
	54	return false;
	55	}
	56
	57
	58	static void LINKAGEMODE
	59	wxImageFloodFill(wxImage *image,
	60	wxCoord x, wxCoord y, const wxBrush & fillBrush,
	61	const wxColour& testColour, int style)
	62	{
	63	/* A diamond flood-fill using a circular queue system.
	64	Each pixel surrounding the current pixel is added to
	65	the queue if it meets the criteria, then is retrieved in
	66	its turn. Code originally based on http://www.drawit.co.nz/Developers.htm,
	67	with explicit permission to use this for wxWidgets granted by Andrew Empson
	68	(no copyright claimed)
	69	*/
	70
	71	int width = image->GetWidth();
	72	int height = image->GetHeight();
	73
	74	//Draw using a pen made from the current brush colour
	75	//Potentially allows us to use patterned flood fills in future code
	76	wxColour fillColour = fillBrush.GetColour();
	77	unsigned char r = fillColour.Red();
	78	unsigned char g = fillColour.Green();
	79	unsigned char b = fillColour.Blue();
	80
	81	//initial test :
	82	if (style == wxFLOOD_SURFACE)
	83	{
	84	//if wxFLOOD_SURFACE, if fill colour is same as required, we don't do anything
	85	if ( image->GetRed(x,y) != r
	86	\|\| image->GetGreen(x,y) != g
	87	\|\| image->GetBlue (x,y) != b )
	88	{
	89	//prepare memory for queue
	90	//queue save, start, read
	91	size_t qs, qst, *qr;
	92
	93	//queue size (physical)
	94	long qSz= height * width * 2;
	95	qst = new size_t [qSz];
	96
	97	//temporary x and y locations
	98	int xt, yt;
	99
	100	for (int i=0; i < qSz; i++)
	101	qst[i] = 0;
	102
	103	// start queue
	104	qs=qr=qst;
	105	*qs=xt=x;
	106	qs++;
	107	*qs=yt=y;
	108	qs++;
	109
	110	image->SetRGB(xt,yt,r,g,b);
	111
	112	//Main queue loop
	113	while(qr!=qs)
	114	{
	115	//Add new members to queue
	116	//Above current pixel
	117	if(MatchPixel(image,xt,yt-1,width,height,testColour))
	118	{
	119	*qs=xt;
	120	qs++;
	121	*qs=yt-1;
	122	qs++;
	123	image->SetRGB(xt,yt-1,r,g,b);
	124
	125	//Loop back to beginning of queue
	126	if(qs>=(qst+qSz)) qs=qst;
	127	}
	128
	129	//Below current pixel
	130	if(MatchPixel(image,xt,yt+1,width,height,testColour))
	131	{
	132	*qs=xt;
	133	qs++;
	134	*qs=yt+1;
	135	qs++;
	136	image->SetRGB(xt,yt+1,r,g,b);
	137	if(qs>=(qst+qSz)) qs=qst;
	138	}
	139
	140	//Left of current pixel
	141	if(MatchPixel(image,xt-1,yt,width,height,testColour))
	142	{
	143	*qs=xt-1;
	144	qs++;
	145	*qs=yt;
	146	qs++;
	147	image->SetRGB(xt-1,yt,r,g,b);
	148	if(qs>=(qst+qSz)) qs=qst;
	149	}
	150
	151	//Right of current pixel
	152	if(MatchPixel(image,xt+1,yt,width,height,testColour))
	153	{
	154	*qs=xt+1;
	155	qs++;
	156	*qs=yt;
	157	qs++;
	158	image->SetRGB(xt+1,yt,r,g,b);
	159	if(qs>=(qst+qSz)) qs=qst;
	160	}
	161
	162	//Retrieve current queue member
	163	qr+=2;
	164
	165	//Loop back to the beginning
	166	if(qr>=(qst+qSz)) qr=qst;
	167	xt=*qr;
	168	yt=*(qr+1);
	169
	170	//Go Back to beginning of loop
	171	}
	172
	173	delete[] qst;
	174	}
	175	}
	176	else
	177	{
	178	//style is wxFLOOD_BORDER
	179	// fill up to testColor border - if already testColour don't do anything
	180	if ( image->GetRed(x,y) != testColour.Red()
	181	\|\| image->GetGreen(x,y) != testColour.Green()
	182	\|\| image->GetBlue(x,y) != testColour.Blue() )
	183	{
	184	//prepare memory for queue
	185	//queue save, start, read
	186	size_t qs, qst, *qr;
	187
	188	//queue size (physical)
	189	long qSz= height * width * 2;
	190	qst = new size_t [qSz];
	191
	192	//temporary x and y locations
	193	int xt, yt;
	194
	195	for (int i=0; i < qSz; i++)
	196	qst[i] = 0;
	197
	198	// start queue
	199	qs=qr=qst;
	200	*qs=xt=x;
	201	qs++;
	202	*qs=yt=y;
	203	qs++;
	204
	205	image->SetRGB(xt,yt,r,g,b);
	206
	207	//Main queue loop
	208	while (qr!=qs)
	209	{
	210	//Add new members to queue
	211	//Above current pixel
	212	if(!MatchBoundaryPixel(image,xt,yt-1,width,height,fillColour,testColour))
	213	{
	214	*qs=xt;
	215	qs++;
	216	*qs=yt-1;
	217	qs++;
	218	image->SetRGB(xt,yt-1,r,g,b);
	219
	220	//Loop back to beginning of queue
	221	if(qs>=(qst+qSz)) qs=qst;
	222	}
	223
	224	//Below current pixel
	225	if(!MatchBoundaryPixel(image,xt,yt+1,width,height,fillColour,testColour))
	226	{
	227	*qs=xt;
	228	qs++;
	229	*qs=yt+1;
	230	qs++;
	231	image->SetRGB(xt,yt+1,r,g,b);
	232	if(qs>=(qst+qSz)) qs=qst;
	233	}
	234
	235	//Left of current pixel
	236	if(!MatchBoundaryPixel(image,xt-1,yt,width,height,fillColour,testColour))
	237	{
	238	*qs=xt-1;
	239	qs++;
	240	*qs=yt;
	241	qs++;
	242	image->SetRGB(xt-1,yt,r,g,b);
	243	if(qs>=(qst+qSz)) qs=qst;
	244	}
	245
	246	//Right of current pixel
	247	if(!MatchBoundaryPixel(image,xt+1,yt,width,height,fillColour,testColour))
	248	{
	249	*qs=xt+1;
	250	qs++;
	251	*qs=yt;
	252	qs++;
	253	image->SetRGB(xt+1,yt,r,g,b);
	254	if(qs>=(qst+qSz)) qs=qst;
	255	}
	256
	257	//Retrieve current queue member
	258	qr+=2;
	259
	260	//Loop back to the beginning
	261	if(qr>=(qst+qSz)) qr=qst;
	262	xt=*qr;
	263	yt=*(qr+1);
	264
	265	//Go Back to beginning of loop
	266	}
	267
	268	delete[] qst;
	269	}
	270	}
	271	//all done,
	272	}
	273
	274
	275	bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
	276	const wxColour& col, wxFloodFillStyle style)
	277	{
	278	if (dc->GetBrush().IsTransparent())
	279	return true;
	280
	281	int height = 0;
	282	int width = 0;
	283	dc->GetSize(&width, &height);
	284
	285	//it would be nice to fail if we don't get a sensible size...
	286	wxCHECK_MSG(width >= 1 && height >= 1, false,
	287	wxT("In FloodFill, dc.GetSize routine failed, method not supported by this DC"));
	288
	289	const int x_dev = dc->LogicalToDeviceX(x);
	290	const int y_dev = dc->LogicalToDeviceY(y);
	291
	292	// if start point is outside dc, can't do anything
	293	if (!wxRect(0, 0, width, height).Contains(x_dev, y_dev))
	294	return false;
	295
	296	wxBitmap bitmap(width, height);
	297	wxMemoryDC memdc(bitmap);
	298	// match dc scales
	299	double sx, sy;
	300	dc->GetUserScale(&sx, &sy);
	301	memdc.SetUserScale(sx, sy);
	302	dc->GetLogicalScale(&sx, &sy);
	303	memdc.SetLogicalScale(sx, sy);
	304
	305	// get logical size and origin
	306	const int w_log = dc->DeviceToLogicalXRel(width);
	307	const int h_log = dc->DeviceToLogicalYRel(height);
	308	const int x0_log = dc->DeviceToLogicalX(0);
	309	const int y0_log = dc->DeviceToLogicalY(0);
	310
	311	memdc.Blit(0, 0, w_log, h_log, dc, x0_log, y0_log);
	312	memdc.SelectObject(wxNullBitmap);
	313
	314	wxImage image = bitmap.ConvertToImage();
	315	wxImageFloodFill(&image, x_dev, y_dev, dc->GetBrush(), col, style);
	316	bitmap = wxBitmap(image);
	317	memdc.SelectObject(bitmap);
	318	dc->Blit(x0_log, y0_log, w_log, h_log, &memdc, 0, 0);
	319
	320	return true;
	321	}
	322
	323	#endif // wxUSE_IMAGE