J'ai une petite fonction qui va recolorer les pixels dans un bitmap d'une couleur donnée à une nouvelle couleur donnée.Remplacer le dégradé de couleurs dans l'image transparente
Les problèmes que j'ai avec le code sont les suivantes:
1) La fonction donne des résultats qui sont REMAPPAGE pixels blancs qui ne devrait pas être concidered depuis que je suis un seuil ... (à moins d'avoir défini cette mauvais calcul)
2) Lorsque certaines couleurs sont données par exemple LIMEGREEN résultats de wierd sont vus dans l'image renvoyée par la fonction (je beleive cela est dû à un débordement du type d'octet dans le cas d'addition ou soustraction)
L'image de base que je me sers se trouve ici:
http://www.freeimagehosting.net/uploads/c8745a9de1.png
Résultats J'ai obtenu peuvent être trouvés ici:
freeimagehosting.net/uploads/fa48e5a0eb.png (appelé avec Color.Magenta comme remapColor, Color.Red comme newColor, on dirait que les pixels blancs sont effectués et la la fin du dégradé n'est pas colorée correctement)
freeimagehosting.net/uploads/8faec6a569.png (appelé avec Color.Magenta comme remapColor, Color.Yellow comme newColor, apparaît comme les pixels blancs sont effectués et la fin du gradient ne sont pas correctement colorés)
freeimagehosting. net/uploads/2efd4c04aa.png (appelé avec Color.Magenta comme remapColor, Color.Blue comme newColor, semble gradient colorés correctement)
freeimagehosting.net/uploads/defdf04e16.png (appelé avec Color.Magenta comme remapColor , Color.Teal comme newColor, Apparaît que les pixels blancs sont appliqués et que le dégradé n'est pas calculé correctement)
La fonction que j'ai pour ce code est ci-dessous: par suggestions À JOUR
public unsafe static Bitmap RecolorImage(Bitmap original, Color remapColor, Color newColor)
{
Bitmap result = new Bitmap(original.Width, original.Height);
//lock the original bitmap in memory
BitmapData originalData = original.LockBits(
new Rectangle(0, 0, original.Width, original.Height),
ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
//lock the new bitmap in memory
BitmapData newData = result.LockBits(
new Rectangle(0, 0, original.Width, original.Height),
ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
//set the number of bytes per pixel
int pixelSize = 4;
int rthreshold = 128;
int gthreshold = 128;
int bthreshold = 128;
for (int y = 0; y < original.Height; y++)
{
//get the data from the original image
byte* oRow = (byte*)originalData.Scan0 + (y * originalData.Stride);
//get the data from the new image
byte* nRow = (byte*)newData.Scan0 + (y * newData.Stride);
for (int x = 0; x < original.Width; x++)
{
//examine the rgb values
byte r = (byte)((oRow[x * pixelSize]));
byte g = (byte)((oRow[x * pixelSize + 1]));
byte b = (byte)((oRow[x * pixelSize + 2]));
byte a = (byte)((oRow[x * pixelSize + 3]));
if (a > 0 &&
Math.Abs(remapColor.R - r) <= rthreshold &&
Math.Abs(remapColor.B - b) <= bthreshold &&
Math.Abs(remapColor.G - g) <= gthreshold
)
{
if (newColor.R == 0)
{
r = 0;
}
else
{
if (newColor.R > remapColor.R)
r = (byte)(r - newColor.R);
else
r = (byte)(r + newColor.R);
}
if (newColor.G == 0)
{
g = 0;
}
else
{
if (newColor.G > remapColor.G)
g = (byte)(g - newColor.G);
else
g = (byte)(g + newColor.G);
}
if (newColor.B == 0)
{
b = 0;
}
else
{
if (newColor.B > remapColor.B)
b = (byte)(b - newColor.B);
else
b = (byte)(b + newColor.B);
}
}
//set the new image's pixel remaped pixel color
nRow[x * pixelSize] = b; //B
nRow[x * pixelSize + 1] = g; //G
nRow[x * pixelSize + 2] = r; //R
nRow[x * pixelSize + 3] = a; //A
}
}
original.UnlockBits(originalData);
result.UnlockBits(newData);
return result;
}
Ce qui donne ....
Est-ce que je suis en train de faire possible?
Est-ce fiable?
Y a-t-il un bogue dans mon code? Y a-t-il une meilleure façon de réaliser cette "technique re-mapable" sur les bitmaps utilisant des gradients?
Nous vous remercions de votre temps.
J'aurais pu aussi modifier un ensemble de couleurs connues dans la palette Bitmap qui aurait affecté l'image globale et serait plus rapide que de définir chaque pixel dans le bitmap! Et nous avons finalement fini par utiliser du XAML ordinaire. Illustrator peut exporter XAML avec un plugin et ainsi nous pourrions éditer les graphiques après avoir été sauvé avec le plugin à la volée! – Jay