Distorção em barril (barrel distortion) ocorre quando a ampliação no centro da lente é maior do que nas extremidades. Lentes olho de peixe (fisheye) produzem este tipo de distorção em resultado de uma cena hemisférica a ser projetada sobre uma superfície plana.
O inverso da distorção em barril é conhecido como pincushion distortion ( distorção almofada de alfinetes) ou inverse barrel distortion.
Para ilustrar estes 2 tipos de distorção vamos utilizar uma imagem com gradeado. Ao lado esquerdo tem-se a imagem original seguida dos efeitos barrel e pincushion respectivamente.
A motivação deste post foi não encontrar nenhum algoritmo interessante para C# (CSharp) realizando estas duas distorções, desta forma após realizar algumas leituras pela internet, e achar muitas formulas que não funcionavam ou estavam incompletas, resolvi criar meu próprio algoritmo. Neste post não entrarei em detalhes do algoritmo, mas somente na forma de utilização final dele, porém o código dele está completo e funcional abaixo.
A chamada principal da função é a:
[sourcecode language="csharp"]
BarrelDistortion(Bitmap sourceImage, double factor, Boolean autoCrop, Color backgroundColor);
[/sourcecode]
Onde:
sourceImage é a imagem que será distorcida;
factor é o fator de distorção, este campo aceita valores de -1 até 1;
autoCrop define se será realizado o corte automático da imagem;
backgroundColor é utilizaso, caso não haja o corte automático da imagem, para preenchimento do fundo.
Exemplo 1:
Neste exemplo será utilizado um fator 0.1 sem corte da imagem.
[sourcecode language="csharp"]
Bitmap bmp = (Bitmap)Bitmap.FromFile("nome_do_arquivo.jpg");
bmp = ImageEfects.BarrelDistortion(bmp, 0.1, false, Color.White);
bmp.Save("images_distorcida.jpg");
bmp.Dispose();
[/sourcecode]
Pode-se observar que o resultado foi uma leve distorção pincushion.
Exemplo 2:
Neste exemplo será utilizado um fator -0.1 sem corte da imagem.
[sourcecode language="csharp"]
Bitmap bmp = (Bitmap)Bitmap.FromFile("nome_do_arquivo.jpg");
bmp = ImageEfects.BarrelDistortion(bmp, -0.1, false, Color.White);
bmp.Save("images_distorcida.jpg");
bmp.Dispose();
[/sourcecode]
Pode-se observar que o resultado foi uma leve distorção de barril.
Por estes 2 efeitos pode-se observar que o fator negativo implica na distorção barril e o positivo na distorção pincushion.
Exemplo 3:
Neste exemplo será utilizado um fator 0.5 sem corte da imagem.
[sourcecode language="csharp"]
Bitmap bmp = (Bitmap)Bitmap.FromFile("nome_do_arquivo.jpg");
bmp = ImageEfects.BarrelDistortion(bmp, 0.5, false, Color.White);
bmp.Save("images_distorcida.jpg");
bmp.Dispose();
[/sourcecode]
Exemplo 4:
Neste exemplo será utilizado um fator -0.5 sem corte da imagem.
[sourcecode language="csharp"]
Bitmap bmp = (Bitmap)Bitmap.FromFile("nome_do_arquivo.jpg");
bmp = ImageEfects.BarrelDistortion(bmp, -0.5, false, Color.White);
bmp.Save("images_distorcida.jpg");
bmp.Dispose();
[/sourcecode]
Exemplo de corte:
Os próximos exemplos utilizam o parâmetro de corte para não deixar áreas vazias na imagem. Em cada um deles será mostrado 2 imagens a primeira com um quadrado vermelho indicando onde será realizado o corte, e a outra, a imagem com o corte realizado.
Exemplo 5:
Neste exemplo será utilizado um fator 0.1 com corte da imagem.
[sourcecode language="csharp"]
Bitmap bmp = (Bitmap)Bitmap.FromFile("nome_do_arquivo.jpg");
bmp = ImageEfects.BarrelDistortion(bmp, 0.1, true, Color.White);
bmp.Save("images_distorcida.jpg");
bmp.Dispose();
[/sourcecode]
Exemplo 6:
Neste exemplo será utilizado um fator -0.1 com corte da imagem.
[sourcecode language="csharp"]
Bitmap bmp = (Bitmap)Bitmap.FromFile("nome_do_arquivo.jpg");
bmp = ImageEfects.BarrelDistortion(bmp, -0.1, true, Color.White);
bmp.Save("images_distorcida.jpg");
bmp.Dispose();
[/sourcecode]
Exemplo 7:
Neste exemplo será utilizado um fator 0.5 com corte da imagem.
[sourcecode language="csharp"]
Bitmap bmp = (Bitmap)Bitmap.FromFile("nome_do_arquivo.jpg");
bmp = ImageEfects.BarrelDistortion(bmp, 0.5, true, Color.White);
bmp.Save("images_distorcida.jpg");
bmp.Dispose();
[/sourcecode]
Exemplo 8:
Neste exemplo será utilizado um fator -0.5 com corte da imagem.
[sourcecode language="csharp"]
Bitmap bmp = (Bitmap)Bitmap.FromFile("nome_do_arquivo.jpg");
bmp = ImageEfects.BarrelDistortion(bmp, -0.5, true, Color.White);
bmp.Save("images_distorcida.jpg");
bmp.Dispose();
[/sourcecode]
Exemplo com fotos reais:
Nestes exemplos será utilizado a foto abaixo:
Fator 0.1 sem corte:
Fator 0.1 com corte:
Fator -0.1 sem corte:
Fator -0.1 com corte:
Para finalizar segue o código completo do aplicativo.
Download: Código fonte Barrel.cs
Código:
[sourcecode language="csharp"]
using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Drawing2D;
using System.Runtime.InteropServices;
namespace HelvioJunior
{
class Program
{
static void Main(string[] args)
{
Bitmap bmp = (Bitmap)Bitmap.FromFile("test.jpg");
bmp = BarrelDistortion(bmp, 0.1, false, Color.White);
bmp.Save("new_test.jpg");
bmp.Dispose();
Console.WriteLine("Pressione ENTER para finalizar");
Console.ReadLine();
}
static public Bitmap BarrelDistortion(Bitmap StartImage, double factor)
{
return BarrelDistortion(StartImage, factor, true, Color.Transparent);
}
static public Bitmap BarrelDistortion(Bitmap sourceImage, double factor, Boolean autoCrop, Color backgroundColor)
{
Bitmap StartImage = null;
BitmapData srcBitmapData = null;
Byte[] srcPixels = null;
Byte[] dstPixels = null;
Bitmap NewImage = null;
BitmapData dstBitmapData = null;
try
{
// Verifica se bpp (Bits Per Pixel) é 8, 24, ou 32
int Depth = System.Drawing.Bitmap.GetPixelFormatSize(sourceImage.PixelFormat);
if (Depth != 8 && Depth != 24 && Depth != 32)
{
throw new ArgumentException("Only 8, 24 and 32 bpp images are supported.");
}
// Recupera a contagem dos componentes de cor
int cCount = Depth / 8;
Size baseSize = new Size(sourceImage.Width, sourceImage.Height);
//verifica se é uma imagem de baixa e precisa redimencionar para melhorar a qualidade
//e não gerar serrilhamento da imagem
Int32 maxSize = Math.Max(sourceImage.Width, sourceImage.Height);
if (maxSize < 3000)
{
float percent = 3000F / (float)maxSize;
baseSize = new Size((Int32)((float)sourceImage.Width * percent), (Int32)((float)sourceImage.Height * percent));
}
StartImage = new Bitmap(baseSize.Width, baseSize.Height, sourceImage.PixelFormat);
StartImage.SetResolution(sourceImage.HorizontalResolution, sourceImage.VerticalResolution);
//Cria o objeto de desenho e fundo branco
Graphics g = Graphics.FromImage(StartImage);
g.SmoothingMode = SmoothingMode.AntiAlias;
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
g.PixelOffsetMode = PixelOffsetMode.HighQuality;
g.DrawImage(sourceImage, new Rectangle(-1, -1, baseSize.Width + 1, baseSize.Height + 1), 0, 0, sourceImage.Width, sourceImage.Height, GraphicsUnit.Pixel);
g.Dispose();
// Bloqueia a imagem de origem e copia para o array de bytes e libera a imagem de origem
srcBitmapData = StartImage.LockBits(new Rectangle(0, 0, StartImage.Width, StartImage.Height), ImageLockMode.ReadOnly, StartImage.PixelFormat);
srcPixels = new byte[StartImage.Width * StartImage.Height * (Depth / 8)];
Marshal.Copy(srcBitmapData.Scan0, srcPixels, 0, srcPixels.Length);
StartImage.UnlockBits(srcBitmapData);
srcBitmapData = null;
//Cria o array de bytes da imagem de destino
dstPixels = new Byte[srcPixels.Length];
//Preenche todo o quadro com a cor de fundo selecionada
Int32 index = ((1 * StartImage.Width) + 1) * cCount; //index = ((Y * Width) + X) * cCount
do
{
if (Depth == 32) // Para 32 bpp define Red, Green, Blue e Alpha
{
dstPixels[index++] = backgroundColor.B;
dstPixels[index++] = backgroundColor.G;
dstPixels[index++] = backgroundColor.R;
dstPixels[index++] = backgroundColor.A; // a
}
if (Depth == 24) // Para 24 bpp define Red, Green e Blue
{
dstPixels[index++] = backgroundColor.B;
dstPixels[index++] = backgroundColor.G;
dstPixels[index++] = backgroundColor.R;
}
if (Depth == 8)
// Para 8 bpp define o valor da cor (Red, Green and Blue como sendo a mesma coisa)
{
dstPixels[index++] = backgroundColor.B;
}
} while (index < srcPixels.Length);
//Calcula a amplitude máxima possível para a imagem e multiplica pelo fator desejados
double amp = 0;
double ang = Math.PI * 0.5;
for (Int32 a = 0; a < StartImage.Height; a++)
{
int y = (int)((StartImage.Height / 2) - amp * Math.Sin(ang));
if ((y < 0) || (y > StartImage.Height))
break;
amp = a;
}
amp = (amp - 2) * (factor < -1 ? -1 : (factor > 1 ? 1 : factor));
//Define variáveis que calcula os pontos de corte (se houver)
Int32 x1, y1, x2, y2;
x1 = StartImage.Width;
y1 = StartImage.Height;
x2 = 0;
y2 = 0;
//Copia pixel a pixel para as novas posições
index = ((1 * StartImage.Width) + 1) * cCount;
do
{
Int32 y = (Int32)((index / cCount) / StartImage.Width);
Int32 x = (index / cCount) - (y * StartImage.Width);
Point pt = NewPoint(new Point(x, y), StartImage.Width, StartImage.Height, amp, factor < 0);
//Valores para crop
if (factor >= 0)
{
if (x == StartImage.Width / 2)
{
if (pt.Y < y1)
y1 = pt.Y;
if (pt.Y > y2)
y2 = pt.Y;
}
if (y == StartImage.Height / 2)
{
if (pt.X < x1)
x1 = pt.X;
if (pt.X > x2)
x2 = pt.X;
}
}
else
{
if ((x == 1) && (y == 1))
{
y1 = pt.Y;
x1 = pt.X;
}
if ((x == StartImage.Width - 1) && (y == StartImage.Height - 1))
{
y2 = pt.Y;
x2 = pt.X;
}
}
//Indice de bytes onde será aplicada o pixel
Int32 dstIndex = ((pt.Y * StartImage.Width) + pt.X) * cCount;
if (Depth == 32)
{
dstPixels[dstIndex] = srcPixels[index++];
dstPixels[dstIndex + 1] = srcPixels[index++];
dstPixels[dstIndex + 2] = srcPixels[index++];
dstPixels[dstIndex + 3] = srcPixels[index++]; // a
}
if (Depth == 24)
{
dstPixels[dstIndex] = srcPixels[index++];
dstPixels[dstIndex + 1] = srcPixels[index++];
dstPixels[dstIndex + 2] = srcPixels[index++];
}
if (Depth == 8)
{
dstPixels[dstIndex] = srcPixels[index++];
}
} while (index < srcPixels.Length);
//Cria a nova imagem com base no array de bytes previamente criado
NewImage = new Bitmap(StartImage.Width, StartImage.Height, StartImage.PixelFormat);
NewImage.SetResolution(StartImage.HorizontalResolution, StartImage.VerticalResolution);
dstBitmapData = NewImage.LockBits(new Rectangle(0, 0, StartImage.Width, StartImage.Height), ImageLockMode.WriteOnly, StartImage.PixelFormat);
Marshal.Copy(dstPixels, 0, dstBitmapData.Scan0, dstPixels.Length);
NewImage.UnlockBits(dstBitmapData);
/*
// Para efeito de visualização, desenha o quadrado onde será realizado o corte
Graphics g2 = Graphics.FromImage(NewImage);
g2.SmoothingMode = SmoothingMode.AntiAlias;
g2.InterpolationMode = InterpolationMode.HighQualityBicubic;
g2.PixelOffsetMode = PixelOffsetMode.HighQuality;
g2.DrawRectangle(new Pen(new SolidBrush(Color.Red), 3), new Rectangle(x1, y1, x2 - x1, y2 - y1));
g2.Dispose();*/
//Gera a imagem final, com crop ou coo o redimencionamento real
Bitmap FinalImage = new Bitmap(sourceImage.Width, sourceImage.Height, StartImage.PixelFormat);
NewImage.SetResolution(StartImage.HorizontalResolution, StartImage.VerticalResolution);
Graphics g1 = Graphics.FromImage(FinalImage);
g1.SmoothingMode = SmoothingMode.AntiAlias;
g1.InterpolationMode = InterpolationMode.HighQualityBicubic;
g1.PixelOffsetMode = PixelOffsetMode.HighQuality;
//Realiza o corte se estiver habilitado o corte automático e houver necessidade de corte
if ((autoCrop) && ((x1 > 0) || (y1 > 0) || (x2 < NewImage.Height) || (y2 < NewImage.Height)))
{
Rectangle cropRect = new Rectangle(x1, y1, x2 - x1, y2 - y1);
g1.DrawImage(NewImage, new Rectangle(-1, -1, FinalImage.Width + 1, FinalImage.Height + 1), cropRect.X, cropRect.Y, cropRect.Width, cropRect.Height, GraphicsUnit.Pixel);
}
else
{
g1.DrawImage(NewImage, new Rectangle(-1, -1, FinalImage.Width + 1, FinalImage.Height + 1), 0, 0, NewImage.Width, NewImage.Height, GraphicsUnit.Pixel);
}
g1.Dispose();
g1 = null;
NewImage = null;
return FinalImage;
}
finally
{
srcBitmapData = null;
srcPixels = null;
dstPixels = null;
dstBitmapData = null;
}
}
private static Point NewPoint(Point AtualPoint, Int32 Width, Int32 Height, double Aplitude, Boolean inverse)
{
Point uP = AtualPoint;
int pY, pX;
double aY, aX;
aY = aX = 0;
double angX = Math.PI * 1 * (double)uP.X / (double)Width;
double caX = Aplitude * ((((double)Height / 2F) - (double)uP.Y) / ((double)Height / 2F));
double angY = Math.PI * 1 * (double)uP.Y / (double)Height;
double caY = Aplitude * ((((double)Width / 2F) - (double)uP.X) / ((double)Width / 2F));
if (inverse)
{
double iAng = Math.PI * -1 * 0.5;
aX = (caX * Math.Sin(iAng));
aY = (caY * Math.Sin(iAng));
}
pY = (int)(uP.Y + aX + caX * Math.Sin(angX));
pX = (int)(uP.X + aY + caY * Math.Sin(angY));
return new Point(pX, pY);
}
}
}
[/sourcecode]