I'm working with directx and it does working only on some of the Bitmaps. Why it's not working on the others ?

Question

The question is not so clear i will try to explain here.
I have a trackBar scroll event:
private void trackBar1_Scroll(object sender, EventArgs e)
LoadPictureAt(trackBar1.Value, sender);
ConvertedBmp = ConvertTo24(trackBar1FileInfo[trackBar1.Value].FullName);
ConvertedBmp.Save(ConvertedBmpDir + "\\ConvertedBmp.bmp");
mymem = ToStream(ConvertedBmp, ImageFormat.Bmp);
backTexture = TextureLoader.FromStream(D3Ddev, mymem);
scannedCloudsTexture = new Texture(D3Ddev, 512, 512, 1, Usage.Dynamic, Format.A8R8G8B8, Pool.Default);
timer1.Stop();
Button1Code();
timer1.Start();
b1 = ConvertedBmp;
b1.Save(ConvertedBmpDir + "\\b1.bmp");
trackBar2.Enabled = false;
if (!this.backgroundWorker1.IsBusy)
label2.Text = "מעבד נתונים";
this.backgroundWorker1.RunWorkerAsync();
else
this.backgroundWorker1.CancelAsync();
First LoadPictureAt method:
private bool LoadPictureAt(int nIndex, object c)
bool bRet = false;
if (nIndex >= 0 && nIndex < trackBar1FileInfo.Length)
if (c.Equals(trackBar1))
pictureBox1.Load(trackBar1FileInfo[nIndex].FullName);
bRet = true;
if (bitmaps != null)
if (nIndex >= 0 && nIndex < bitmaps.Length)
if (c.Equals(trackBar2))
pictureBox1.Image = bitmaps[nIndex];
bRet = true;
return bRet;
Then the ConvertTo24 method:
private Bitmap ConvertTo24(string inputFileName)
sw = Stopwatch.StartNew();
Bitmap bmpIn = (Bitmap)Bitmap.FromFile(inputFileName);
Bitmap converted = new Bitmap(bmpIn.Width, bmpIn.Height, PixelFormat.Format24bppRgb);
using (Graphics g = Graphics.FromImage(converted))
// Prevent DPI conversion
g.PageUnit = GraphicsUnit.Pixel;
// Draw the image
g.DrawImageUnscaled(bmpIn, 0, 0);
//converted.Save(outputFileName, ImageFormat.Bmp);
sw.Stop();
return converted;
Then ToStream method:
public static Stream ToStream(Image image, ImageFormat formaw)
var stream = new System.IO.MemoryStream();
image.Save(stream, formaw);
stream.Position = 0;
return stream;
What it does is taking a Bitmap image and make a doppler radar effect on it and detect color only places that there are pixels(clouds) in it.
Here is a screenshot:
You can see the doppler shape and it's moving around and highlight the places with clouds.
So when i move the trackBar1 to the left each time on another Bitmap image it's showing the doppler effect and the clouds.
The problem is with the trackBar2 scroll event:
First when i'm running my program and enteric to this new form that scan the clouds and show the doppler radar effect a backgroundworker1 is working:
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
BackgroundWorker bgw = (BackgroundWorker)sender;
if (bgw.CancellationPending == true)
return;
else
while (true)
bitmaps = ImagesComparison.get_images_with_clouds(b1);
for (int i = 0; i < bitmaps.Length; i++)
bitmaps[i] = ConvertTo1or8Bit.ColorToGrayscale(bitmaps[i]);
break;
What it does is getting into bitmaps(Bitmap[])  15 new bitmaps from one given bitmap. The given bitmap is b1.
b1 i'm using it in trackBar1 scroll event.
All the new Bitmaps in bitmaps variable array are Format32bppArgb.
While i checked on my hard disk the images(GIF type) i'm using with trackBar1 are all Bit Depth 8.
The images i'm using with trackBar1 scroll event are GIF types and Bit Depth 8 on the properties.
The images i'm using in trackBar2 are Bitmaps and they are Format32bppArgb.
So first thing i thought to convert all the 15 Bitmaps in bitmaps to 8bit:
for (int i = 0; i < bitmaps.Length; i++)
bitmaps[i] = ConvertTo1or8Bit.ColorToGrayscale(bitmaps[i]);
But it didn't work it's just turning them to black gray scale colors not what i was thinking about.
In the backgroundworker completed event i'm converting the bitmaps to 24 like i'm doing with the Gifs in trackBar1 scroll event:
private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
trackBar2.Enabled = true;
trackBar2.Maximum = bitmaps.Length -1;
bitmaps[0].Save(ConvertedBmpDir + "\\bitmapsfirstimage.bmp");
for (int i = 0; i < bitmaps.Length; i++)
ConvertedBitmaps.Add(ConvertTo24(bitmaps[i]));
ConvertedBitmaps[0].Save(ConvertedBmpDir + "\\ConvertedBitmapsFirstImage.bmp");
label2.Text = "עיבוד הנתונים הסתיים";
b1.Dispose();
Then in the trackBar2 scroll event:
private void trackBar2_Scroll(object sender, EventArgs e)
LoadPictureAt(trackBar2.Value, sender);
ConvertedBmp = ConvertedBitmaps[trackBar2.Value - 1];
ConvertedBmp.Save(ConvertedBmpDir + "\\ConvertedBmp.bmp");
mymem = ToStream(ConvertedBmp, ImageFormat.Bmp);
backTexture = TextureLoader.FromStream(D3Ddev, mymem);
scannedCloudsTexture = new Texture(D3Ddev, 512, 512, 1, Usage.Dynamic, Format.A8R8G8B8, Pool.Default);
timer1.Stop();
Button1Code();
timer1.Start();
The same i did with the trackBar1 scroll event.
But the result in trackBar2 i'm getting without using the grayscale convertion is this:
You can see that the color that make the scan now is more yellow or green/yellow and not the same like it is when i'm using the trackBar1.
I can't figure out where the problem is:
1. Maybe since the Bitmaps in the variable array bitmaps are all Format32bppArgb ?
2. Maybe they are Bitmaps and not Gif types like the images in trackBar1 ?
If it does working good with the gifs in trackBar1 scroll event then the whole code in the new form ScanningClouds is working fine so i will not add to here the whole ScanningClouds form code since it's long.
The problem is somewhere with the Bitmaps formas or bits in the variable bitmaps.
Maybe they are not the same or the right Bit Depth or maybe they are Bitmaps and should be Gifs.
bitmaps = ImagesComparison.get_images_with_clouds(b1);
This is the get_images_with_clouds method where i'm getting the new 15 Bitmaps.
public static Bitmap[] get_images_with_clouds(Bitmap radar_image)
int e = 0;
int f = 0;
int image_clock_area_x = 0;
int image_clock_area_y = 0;
int image_clock_area_x1 = 140;
int image_clock_area_y1 = 21;
Bitmap[] localImages;
localImages = new Bitmap[15];
Bitmap image;
image = new Bitmap(Properties.Resources.radar_without_clouds);
BitmapData bmD = null;
BitmapData bmD2 = null;
try
bmD = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadWrite,
PixelFormat.Format32bppArgb);
bmD2 = radar_image.LockBits(new Rectangle(0, 0, radar_image.Width, radar_image.Height), ImageLockMode.ReadOnly,
PixelFormat.Format32bppArgb);
IntPtr sc0 = bmD.Scan0;
unsafe
int* p = (int*)sc0.ToPointer();
int* p2 = (int*)bmD2.Scan0.ToPointer();
for (e = image_clock_area_x; e < image_clock_area_x + image_clock_area_x1; e++)
for (f = image_clock_area_y; f < image_clock_area_y + image_clock_area_y1; f++)
Color clock_color = Color.FromArgb(p2[e + f * bmD2.Width]);
p[e + f * bmD.Width] = clock_color.ToArgb();
image.UnlockBits(bmD);
radar_image.UnlockBits(bmD2);
catch
try
image.UnlockBits(bmD);
catch
try
radar_image.UnlockBits(bmD2);
catch
int c;
for (c = 0; c < localImages.Length; c++)
localImages[c] = new Bitmap(image);
Bitmap new_image = new Bitmap(Properties.Resources.radar_without_clouds);
Bitmap new_image1 = new Bitmap(Properties.Resources.radar_without_clouds);
Bitmap localbmptest = black_and_white(new_image, radar_image);
Image image1 = black_and_white(new_image, radar_image);
image1.Save(@"c:\temp\testclouds666.jpg");
Bitmap clouds = new Bitmap(image1);
int x;
int y;
int a;
int b;
int d = 0;
Bitmap redImage;
redImage = new Bitmap(512, 512);
using (Graphics g = Graphics.FromImage(redImage))
g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;
g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.Half;
g.Clear(Color.Red);
BitmapData bmData = null;
BitmapData bmData2 = null;
BitmapData bmDataArray = null;
try
bmData = clouds.LockBits(new Rectangle(0, 0, clouds.Width, clouds.Height), ImageLockMode.ReadOnly,
PixelFormat.Format32bppArgb);
bmData2 = radar_image.LockBits(new Rectangle(0, 0, radar_image.Width, radar_image.Height), ImageLockMode.ReadOnly,
PixelFormat.Format32bppArgb);
IntPtr scan0 = bmData.Scan0;
IntPtr scan02 = bmData2.Scan0;
unsafe
int* p = (int*)scan0.ToPointer();
int* p2 = (int*)scan02.ToPointer();
double h, mm;
for (d = 0; d < localImages.Length; d++)
bmDataArray = localImages[d].LockBits(new Rectangle(0, 0, localImages[d].Width, localImages[d].Height), ImageLockMode.ReadWrite,
PixelFormat.Format32bppArgb);
IntPtr scan0Array = bmDataArray.Scan0;
int* pArray = (int*)scan0Array.ToPointer();
for (a = 0; a < new_image.Width; a++)
for (b = 0; b < new_image.Height; b++)
Color color1 = Color.FromArgb(p[a + b * bmData.Width]);
Color color2 = Color.FromArgb(p2[a + b * bmData2.Width]);
if (color1.R != 0 || color1.G != 0 || color1.B != 0)
h = color2.GetHue();
mm = RadarAnalysis.Hue2MMPerHour(h);
if (mm >= treshhold_array[14 - d])
pArray[a + b * bmDataArray.Width] = color2.ToArgb();
localImages[d].UnlockBits(bmDataArray);
clouds.UnlockBits(bmData);
radar_image.UnlockBits(bmData2);
catch (Exception error)
try
clouds.UnlockBits(bmData);
catch
try
radar_image.UnlockBits(bmData2);
catch
try
localImages[d].UnlockBits(bmDataArray);
catch
Logger.Write("Error Exception ==> " + error);
MessageBox.Show("Error Exception ==> " + error);
return localImages;
I think not sure but i think the problem is that the images on my hard disk i'm using with the trackBar1 scroll event are Gif type and the images i'm using with the trackBar2 scroll event are 15 Bitmaps.

Answer 1

Hi,
"But it didn't work it's just turning them to black gray scale colors not what i was thinking about."
If you want it to be colored, you'll need to create a color-palette for the 8bppIndexed bitmaps. The keyword for this process is "Color-Quantization".
The whole yellow-green pie you get is from the wrong format. If you convert the 32bpp bitmaps to 24 bpp bitmaps, you loose the alpha channel ("transparency"). You can manually set one color to "transparent" with the mMakeTransparent-method
of the Bitmap class, or simply use gif-images (they are 8bpp with a transparent "key"-color)
Regards,
  Thorsten