By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
458,222 Members | 1,079 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 458,222 IT Pros & Developers. It's quick & easy.

Anyone can help me?How to Convert C# to VB.NET, about Flood Fill

P: n/a
//Thanks for any help,thank you!лл

public override void FloodFill(Bitmap bmp, Point pt)
{
int ctr=timeGetTime();

//Debug.WriteLine("*******Flood Fill******");

//get the color's int value, and convert it from RGBA to BGRA format (as
GDI+ uses BGRA)
m_fillcolor=ColorTranslator.ToWin32(m_fillcolorcol or);
m_fillcolor=BGRA(GetB(m_fillcolor),GetG(m_fillcolo r),GetR(m_fillcolor),GetA(m_fillcolor));

//get the bits
BitmapData bmpData=bmp.LockBits(new
Rectangle(0,0,bmp.Width,bmp.Height),ImageLockMode. ReadWrite,PixelFormat.Format32bppArgb);
System.IntPtr Scan0 = bmpData.Scan0;

unsafe
{
//resolve pointer
byte * scan0=(byte *)(void *)Scan0;
//get the starting color
//[loc += Y offset + X offset]
int
loc=CoordsToIndex(pt.X,pt.Y,bmpData.Stride);//((bmpData.Stride*(pt.Y-1))+(pt.X*4));
int color= *((int*)(scan0+loc));

//create the array of bools that indicates whether each pixel
//has been checked. (Should be bitfield, but C#
doesn't support bitfields.)
PixelsChecked=new
bool[bmpData.Width+1,bmpData.Height+1];

//do the first call to the loop

LinearFloodFill4(scan0,pt.X,pt.Y,new
Size(bmpData.Width,bmpData.Height),bmpData.Stride, (byte*)&color);

}

bmp.UnlockBits(bmpData);

m_TimeBenchmark=timeGetTime()-ctr;

}

//***********
//LINEAR ALGORITHM
//***********

unsafe void LinearFloodFill4( byte* scan0, int x, int y,Size bmpsize, int
stride, byte* startcolor)
{

//offset the pointer to the point passed in
int* p=(int*) (scan0+(CoordsToIndex(x,y, stride)));
//FIND LEFT EDGE OF COLOR AREA
int LFillLoc=x; //the location to check/fill on the left
int* ptr=p; //the pointer to the current location
while(true)
{
ptr[0]=m_fillcolor; //fill with the color
PixelsChecked[LFillLoc,y]=true;
LFillLoc--; //de-increment counter
ptr-=1; //de-increment pointer
if(LFillLoc<=0 || !CheckPixel((byte*)ptr,startcolor) ||
(PixelsChecked[LFillLoc,y]))
break; //exit loop if we're at edge of bitmap or color area

}
LFillLoc++;

//FIND RIGHT EDGE OF COLOR AREA
int RFillLoc=x; //the location to check/fill on the left
ptr=p;
while(true)
{
ptr[0]=m_fillcolor; //fill with the color
PixelsChecked[RFillLoc,y]=true;
RFillLoc++; //increment counter
ptr+=1; //increment pointer
if(RFillLoc>=bmpsize.Width || !CheckPixel((byte*)ptr,startcolor) ||
(PixelsChecked[RFillLoc,y]))
break; //exit loop if we're at edge of bitmap or color area

}
RFillLoc--;
//START THE LOOP UPWARDS AND DOWNWARDS
ptr=(int*)(scan0+CoordsToIndex(LFillLoc,y,stride)) ;
for(int i=LFillLoc;i<=RFillLoc;i++)
{
//START LOOP UPWARDS
//if we're not above the top of the bitmap and the pixel above this one is
within the color tolerance
if(y>0 && CheckPixel((byte*)(scan0+CoordsToIndex(i,y-1,stride)),startcolor)
&& (!(PixelsChecked[i,y-1])))
LinearFloodFill4(scan0, i,y-1,bmpsize,stride,startcolor);
//START LOOP DOWNWARDS
if(y<(bmpsize.Height-1) &&
CheckPixel((byte*)(scan0+CoordsToIndex(i,y+1,strid e)),startcolor) &&
(!(PixelsChecked[i,y+1])))
LinearFloodFill4(scan0, i,y+1,bmpsize,stride,startcolor);
ptr+=1;
}

}
Jul 26 '06 #1
Share this Question
Share on Google+
4 Replies


P: n/a
This code is not a straight forward translation as the C# version is using
unsafe code.

VB>NET does not support unsafe code .. to remove the unsafe code would
change drastically the performance of the algorithm. I would probably leave
it in C# if that is at all an option.

Cheers,

Greg Young
MVP - C#
http://codebetter.com/blogs/gregyoung

"eking" <ab*@123.comwrote in message
news:ei**************@TK2MSFTNGP06.phx.gbl...
//Thanks for any help,thank you!лл

public override void FloodFill(Bitmap bmp, Point pt)
{
int ctr=timeGetTime();

//Debug.WriteLine("*******Flood Fill******");

//get the color's int value, and convert it from RGBA to BGRA format (as
GDI+ uses BGRA)

m_fillcolor=ColorTranslator.ToWin32(m_fillcolorcol or);
m_fillcolor=BGRA(GetB(m_fillcolor),GetG(m_fillcolo r),GetR(m_fillcolor),GetA(m_fillcolor));

//get the bits
BitmapData bmpData=bmp.LockBits(new
Rectangle(0,0,bmp.Width,bmp.Height),ImageLockMode. ReadWrite,PixelFormat.Format32bppArgb);
System.IntPtr Scan0 = bmpData.Scan0;

unsafe
{
//resolve pointer
byte * scan0=(byte *)(void *)Scan0;
//get the starting color
//[loc += Y offset + X offset]
int
loc=CoordsToIndex(pt.X,pt.Y,bmpData.Stride);//((bmpData.Stride*(pt.Y-1))+(pt.X*4));
int color= *((int*)(scan0+loc));

//create the array of bools that indicates whether each pixel
//has been checked. (Should be bitfield, but C#
doesn't support bitfields.)
PixelsChecked=new
bool[bmpData.Width+1,bmpData.Height+1];

//do the first call to the loop

LinearFloodFill4(scan0,pt.X,pt.Y,new
Size(bmpData.Width,bmpData.Height),bmpData.Stride, (byte*)&color);

}

bmp.UnlockBits(bmpData);

m_TimeBenchmark=timeGetTime()-ctr;

}

//***********
//LINEAR ALGORITHM
//***********

unsafe void LinearFloodFill4( byte* scan0, int x, int y,Size bmpsize, int
stride, byte* startcolor)
{

//offset the pointer to the point passed in
int* p=(int*) (scan0+(CoordsToIndex(x,y, stride)));
//FIND LEFT EDGE OF COLOR AREA
int LFillLoc=x; //the location to check/fill on the left
int* ptr=p; //the pointer to the current location
while(true)
{
ptr[0]=m_fillcolor; //fill with the color
PixelsChecked[LFillLoc,y]=true;
LFillLoc--; //de-increment counter
ptr-=1; //de-increment pointer
if(LFillLoc<=0 || !CheckPixel((byte*)ptr,startcolor) ||
(PixelsChecked[LFillLoc,y]))
break; //exit loop if we're at edge of bitmap or color area

}
LFillLoc++;

//FIND RIGHT EDGE OF COLOR AREA
int RFillLoc=x; //the location to check/fill on the left
ptr=p;
while(true)
{
ptr[0]=m_fillcolor; //fill with the color
PixelsChecked[RFillLoc,y]=true;
RFillLoc++; //increment counter
ptr+=1; //increment pointer
if(RFillLoc>=bmpsize.Width || !CheckPixel((byte*)ptr,startcolor) ||
(PixelsChecked[RFillLoc,y]))
break; //exit loop if we're at edge of bitmap or color area

}
RFillLoc--;
//START THE LOOP UPWARDS AND DOWNWARDS
ptr=(int*)(scan0+CoordsToIndex(LFillLoc,y,stride)) ;
for(int i=LFillLoc;i<=RFillLoc;i++)
{
//START LOOP UPWARDS
//if we're not above the top of the bitmap and the pixel above this one is
within the color tolerance
if(y>0 &&
CheckPixel((byte*)(scan0+CoordsToIndex(i,y-1,stride)),startcolor)
&& (!(PixelsChecked[i,y-1])))
LinearFloodFill4(scan0, i,y-1,bmpsize,stride,startcolor);
//START LOOP DOWNWARDS
if(y<(bmpsize.Height-1) &&
CheckPixel((byte*)(scan0+CoordsToIndex(i,y+1,strid e)),startcolor) &&
(!(PixelsChecked[i,y+1])))
LinearFloodFill4(scan0, i,y+1,bmpsize,stride,startcolor);
ptr+=1;
}

}


Jul 26 '06 #2

P: n/a
As Addition to Greg,

Where an option can be to create a small C# project as DLL library, to Add
that as existing to your project and set a Project Reference using the
Project -Add References -Projects in your VBNet project.

Cor
"Greg Young" <dr*******************@hotmail.comschreef in bericht
news:%2****************@TK2MSFTNGP06.phx.gbl...
This code is not a straight forward translation as the C# version is using
unsafe code.

VB>NET does not support unsafe code .. to remove the unsafe code would
change drastically the performance of the algorithm. I would probably
leave it in C# if that is at all an option.

Cheers,

Greg Young
MVP - C#
http://codebetter.com/blogs/gregyoung

"eking" <ab*@123.comwrote in message
news:ei**************@TK2MSFTNGP06.phx.gbl...
>//Thanks for any help,thank you!лл

public override void FloodFill(Bitmap bmp, Point pt)
{
int ctr=timeGetTime();

//Debug.WriteLine("*******Flood Fill******");

//get the color's int value, and convert it from RGBA to BGRA format (as
GDI+ uses BGRA)

m_fillcolor=ColorTranslator.ToWin32(m_fillcolorco lor);
m_fillcolor=BGRA(GetB(m_fillcolor),GetG(m_fillcol or),GetR(m_fillcolor),GetA(m_fillcolor));

//get the bits
BitmapData bmpData=bmp.LockBits(new
Rectangle(0,0,bmp.Width,bmp.Height),ImageLockMode .ReadWrite,PixelFormat.Format32bppArgb);
System.IntPtr Scan0 = bmpData.Scan0;

unsafe
{
//resolve pointer
byte * scan0=(byte *)(void *)Scan0;
//get the starting color
//[loc += Y offset + X offset]
int
loc=CoordsToIndex(pt.X,pt.Y,bmpData.Stride);//((bmpData.Stride*(pt.Y-1))+(pt.X*4));
int color= *((int*)(scan0+loc));

//create the array of bools that indicates whether each pixel
//has been checked. (Should be bitfield, but C#
doesn't support bitfields.)
PixelsChecked=new
bool[bmpData.Width+1,bmpData.Height+1];

//do the first call to the loop

LinearFloodFill4(scan0,pt.X,pt.Y,new
Size(bmpData.Width,bmpData.Height),bmpData.Stride ,(byte*)&color);

}

bmp.UnlockBits(bmpData);

m_TimeBenchmark=timeGetTime()-ctr;

}

//***********
//LINEAR ALGORITHM
//***********

unsafe void LinearFloodFill4( byte* scan0, int x, int y,Size bmpsize, int
stride, byte* startcolor)
{

//offset the pointer to the point passed in
int* p=(int*) (scan0+(CoordsToIndex(x,y, stride)));
//FIND LEFT EDGE OF COLOR AREA
int LFillLoc=x; //the location to check/fill on the left
int* ptr=p; //the pointer to the current location
while(true)
{
ptr[0]=m_fillcolor; //fill with the color
PixelsChecked[LFillLoc,y]=true;
LFillLoc--; //de-increment counter
ptr-=1; //de-increment pointer
if(LFillLoc<=0 || !CheckPixel((byte*)ptr,startcolor) ||
(PixelsChecked[LFillLoc,y]))
break; //exit loop if we're at edge of bitmap or color area

}
LFillLoc++;

//FIND RIGHT EDGE OF COLOR AREA
int RFillLoc=x; //the location to check/fill on the left
ptr=p;
while(true)
{
ptr[0]=m_fillcolor; //fill with the color
PixelsChecked[RFillLoc,y]=true;
RFillLoc++; //increment counter
ptr+=1; //increment pointer
if(RFillLoc>=bmpsize.Width || !CheckPixel((byte*)ptr,startcolor) ||
(PixelsChecked[RFillLoc,y]))
break; //exit loop if we're at edge of bitmap or color area

}
RFillLoc--;
//START THE LOOP UPWARDS AND DOWNWARDS
ptr=(int*)(scan0+CoordsToIndex(LFillLoc,y,stride) );
for(int i=LFillLoc;i<=RFillLoc;i++)
{
//START LOOP UPWARDS
//if we're not above the top of the bitmap and the pixel above this one
is
within the color tolerance
if(y>0 &&
CheckPixel((byte*)(scan0+CoordsToIndex(i,y-1,stride)),startcolor)
&& (!(PixelsChecked[i,y-1])))
LinearFloodFill4(scan0, i,y-1,bmpsize,stride,startcolor);
//START LOOP DOWNWARDS
if(y<(bmpsize.Height-1) &&
CheckPixel((byte*)(scan0+CoordsToIndex(i,y+1,stri de)),startcolor) &&
(!(PixelsChecked[i,y+1])))
LinearFloodFill4(scan0, i,y+1,bmpsize,stride,startcolor);
ptr+=1;
}

}



Jul 26 '06 #3

P: n/a
There is no possible automatic translation of 'unsafe' C# code to VB (this is
also one of the reasons you can't automatically translate C++ code to VB).
The code must be redesigned for VB.
--
David Anton
www.tangiblesoftwaresolutions.com
Instant C#: VB to C# converter
Instant VB: C# to VB converter
Instant C++: C#/VB to C++ converter
C# Code Metrics: Quick metrics for C#
"eking" wrote:
//Thanks for any help,thank you!谢谢。

public override void FloodFill(Bitmap bmp, Point pt)
{
int ctr=timeGetTime();

//Debug.WriteLine("*******Flood Fill******");

//get the color's int value, and convert it from RGBA to BGRA format (as
GDI+ uses BGRA)
m_fillcolor=ColorTranslator.ToWin32(m_fillcolorcol or);
m_fillcolor=BGRA(GetB(m_fillcolor),GetG(m_fillcolo r),GetR(m_fillcolor),GetA(m_fillcolor));

//get the bits
BitmapData bmpData=bmp.LockBits(new
Rectangle(0,0,bmp.Width,bmp.Height),ImageLockMode. ReadWrite,PixelFormat.Format32bppArgb);
System.IntPtr Scan0 = bmpData.Scan0;

unsafe
{
//resolve pointer
byte * scan0=(byte *)(void *)Scan0;
//get the starting color
//[loc += Y offset + X offset]
int
loc=CoordsToIndex(pt.X,pt.Y,bmpData.Stride);//((bmpData.Stride*(pt.Y-1))+(pt.X*4));
int color= *((int*)(scan0+loc));

//create the array of bools that indicates whether each pixel
//has been checked. (Should be bitfield, but C#
doesn't support bitfields.)
PixelsChecked=new
bool[bmpData.Width+1,bmpData.Height+1];

//do the first call to the loop

LinearFloodFill4(scan0,pt.X,pt.Y,new
Size(bmpData.Width,bmpData.Height),bmpData.Stride, (byte*)&color);

}

bmp.UnlockBits(bmpData);

m_TimeBenchmark=timeGetTime()-ctr;

}

//***********
//LINEAR ALGORITHM
//***********

unsafe void LinearFloodFill4( byte* scan0, int x, int y,Size bmpsize, int
stride, byte* startcolor)
{

//offset the pointer to the point passed in
int* p=(int*) (scan0+(CoordsToIndex(x,y, stride)));
//FIND LEFT EDGE OF COLOR AREA
int LFillLoc=x; //the location to check/fill on the left
int* ptr=p; //the pointer to the current location
while(true)
{
ptr[0]=m_fillcolor; //fill with the color
PixelsChecked[LFillLoc,y]=true;
LFillLoc--; //de-increment counter
ptr-=1; //de-increment pointer
if(LFillLoc<=0 || !CheckPixel((byte*)ptr,startcolor) ||
(PixelsChecked[LFillLoc,y]))
break; //exit loop if we're at edge of bitmap or color area

}
LFillLoc++;

//FIND RIGHT EDGE OF COLOR AREA
int RFillLoc=x; //the location to check/fill on the left
ptr=p;
while(true)
{
ptr[0]=m_fillcolor; //fill with the color
PixelsChecked[RFillLoc,y]=true;
RFillLoc++; //increment counter
ptr+=1; //increment pointer
if(RFillLoc>=bmpsize.Width || !CheckPixel((byte*)ptr,startcolor) ||
(PixelsChecked[RFillLoc,y]))
break; //exit loop if we're at edge of bitmap or color area

}
RFillLoc--;
//START THE LOOP UPWARDS AND DOWNWARDS
ptr=(int*)(scan0+CoordsToIndex(LFillLoc,y,stride)) ;
for(int i=LFillLoc;i<=RFillLoc;i++)
{
//START LOOP UPWARDS
//if we're not above the top of the bitmap and the pixel above this one is
within the color tolerance
if(y>0 && CheckPixel((byte*)(scan0+CoordsToIndex(i,y-1,stride)),startcolor)
&& (!(PixelsChecked[i,y-1])))
LinearFloodFill4(scan0, i,y-1,bmpsize,stride,startcolor);
//START LOOP DOWNWARDS
if(y<(bmpsize.Height-1) &&
CheckPixel((byte*)(scan0+CoordsToIndex(i,y+1,strid e)),startcolor) &&
(!(PixelsChecked[i,y+1])))
LinearFloodFill4(scan0, i,y+1,bmpsize,stride,startcolor);
ptr+=1;
}

}
Jul 26 '06 #4

P: n/a

"Cor Ligthert [MVP]" <no************@planet.nlдϢ
news:O%****************@TK2MSFTNGP04.phx.gbl...
As Addition to Greg,

Where an option can be to create a small C# project as DLL library, to Add
that as existing to your project and set a Project Reference using the
Jul 27 '06 #5

This discussion thread is closed

Replies have been disabled for this discussion.