Barrel and pincushion distortion

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:

BarrelDistortion(Bitmap sourceImage, double factor, Boolean autoCrop, Color backgroundColor);

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.

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();

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.

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();

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.

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();

Exemplo 4:
Neste exemplo será utilizado um fator -0.5 sem corte da imagem.

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();

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.

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();

Exemplo 6:
Neste exemplo será utilizado um fator -0.1 com corte da imagem.

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();

Exemplo 7:
Neste exemplo será utilizado um fator 0.5 com corte da imagem.

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();

Exemplo 8:
Neste exemplo será utilizado um fator -0.5 com corte da imagem.

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();

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:

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);

}

}
}
Helvio Junior (OSCE, OSCP, CEHv9)

Helvio Junior (OSCE, OSCP, CEHv9)

Consultor em Cyber Security em Ernst & Young (EY)
OSCE, OSCP, CEHv9, Pesquisador de Falhas de Segurança e Vulnerabilidades. Profissional com mais de 20 anos de experiência na área de TI, atualmente focado na área de segurança da informação ofensiva (Red Team), bug hunting, cyber threat hunting, criação e engenharia reversa de Malware.
Carreira baseada em sólidos conhecimentos técnicos nas principais tecnologias de TI: Penetration Testing, Clould Computing, Ambiente de alta criticidade e alta disponibilidade, Windows Servers e seus serviços, Linux Servers e seus serviços, VoIP com Asterisk, Redes, Cisco, HP, ISO 27002, Hacker ético (CEHv9) e Engenharia reversa.
Helvio Junior (OSCE, OSCP, CEHv9)
0 respostas

Deixe uma resposta

Want to join the discussion?
Feel free to contribute!

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *