Home All Groups Group Topic Archive Search About

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

microsoft.public.dotnet.languages.vb
Author
26 Jul 2006 2:56 AM
eking
//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_fillcolorcolor);
m_fillcolor=BGRA(GetB(m_fillcolor),GetG(m_fillcolor),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,stride)),startcolor) &&
(!(PixelsChecked[i,y+1])))
LinearFloodFill4(scan0, i,y+1,bmpsize,stride,startcolor);
ptr+=1;
}

}

Author
26 Jul 2006 4:42 AM
Greg Young
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

Show quoteHide quote
"eking" <a**@123.com> wrote in message
news:eikdp8FsGHA.1300@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_fillcolorcolor);
> m_fillcolor=BGRA(GetB(m_fillcolor),GetG(m_fillcolor),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,stride)),startcolor) &&
> (!(PixelsChecked[i,y+1])))
> LinearFloodFill4(scan0, i,y+1,bmpsize,stride,startcolor);
> ptr+=1;
> }
>
> }
>
>
Author
26 Jul 2006 7:08 AM
Cor Ligthert [MVP]
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


Show quoteHide quote
"Greg Young" <druckdruckREMOVEgo***@hotmail.com> schreef in bericht
news:%237iyk3GsGHA.4152@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" <a**@123.com> wrote in message
> news:eikdp8FsGHA.1300@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_fillcolorcolor);
>> m_fillcolor=BGRA(GetB(m_fillcolor),GetG(m_fillcolor),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,stride)),startcolor) &&
>> (!(PixelsChecked[i,y+1])))
>> LinearFloodFill4(scan0, i,y+1,bmpsize,stride,startcolor);
>> ptr+=1;
>> }
>>
>> }
>>
>>
>
>
Author
27 Jul 2006 1:46 AM
eking
"Cor Ligthert [MVP]" <notmyfirstn***@planet.nl> дÈëÏûÏ¢
news:O%23KP0IIsGHA.4596@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
Author
26 Jul 2006 2:46 PM
David Anton
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#


Show quoteHide quote
"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_fillcolorcolor);
> m_fillcolor=BGRA(GetB(m_fillcolor),GetG(m_fillcolor),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,stride)),startcolor) &&
> (!(PixelsChecked[i,y+1])))
> LinearFloodFill4(scan0, i,y+1,bmpsize,stride,startcolor);
> ptr+=1;
> }
>
> }
>
>
>



Post Other interesting topics
What is an assembly?
silly, probably meaninigless question
DEBUG: can we disable try/catch ?
Microsoft (R) Visual Basic Compiler has encountered a problem and needs to close. :o(
Programmable LEGO blocks?
How to ping an IP address by using sockets in Visual Basic .NET
No accessible overloaded
Disabling the Form Designer
Can WinCE & Pocket PC support the "AsyncCallback"?
How is it work?