void ReallocLut(double radius)
{
_radius = radius;
_diameter = AggMath.uceil(radius) * 2;
_start = -(_diameter / 2 - 1);
int size = _diameter << ImgSubPixConst.SHIFT;
if (size > _weight_array.Length)
{
_weight_array = new int[size];
}
}
//
public void Rebuild(Imaging.IImageFilterFunc filterFunc, bool normalization = true)
{
double r = filterFunc.GetRadius();
//---------------
_radius = r;
_diameter = AggMath.uceil(r) * 2;
_start = -((_diameter / 2) - 1);
int size = _diameter << ImgSubPixConst.SHIFT;
if (size > _weight_array.Length)
{
_weight_array = new int[size];
}
else if (size < _weight_array.Length)
{
_weight_array = new int[size];
}
//---------------
int i;
int pivot = Diameter << (ImgSubPixConst.SHIFT - 1);
for (i = 0; i < pivot; i++)
{
double x = (double)i / (double)ImgSubPixConst.SCALE;
double y = filterFunc.CalculateWeight(x);
_weight_array[pivot + i] =
_weight_array[pivot - i] = AggMath.iround(y * ImgFilterConst.SCALE);
}
int end = (Diameter << ImgSubPixConst.SHIFT) - 1;
_weight_array[0] = _weight_array[end];
if (normalization)
{
Normalize();
}
}
// Create
//--------------------------------------------------------------------
public void Create(IBitmapSrc src)
{
// we are going to create a dialated image for filtering
// we add m_dilation pixels to every side of the image and then copy the image in the x
// dirrection into each end so that we can sample into this image to get filtering on x repeating
// if the original image look like this
//
// 123456
//
// the new image would look like this
//
// 0000000000
// 0000000000
// 5612345612
// 0000000000
// 0000000000
_height = (int)AggMath.uceil(src.Height);
_width = (int)AggMath.uceil(src.Width);
_width_hr = (int)AggMath.uround(src.Width * LineAA.SUBPIXEL_SCALE);
_half_height_hr = (int)AggMath.uround(src.Height * LineAA.SUBPIXEL_SCALE / 2);
_offset_y_hr = _dilation_hr + _half_height_hr - LineAA.SUBPIXEL_SCALE / 2;
_half_height_hr += LineAA.SUBPIXEL_SCALE / 2;
int bufferWidth = _width + _dilation * 2;
int bufferHeight = _height + _dilation * 2;
int bytesPerPixel = src.BitDepth / 8;
int newSizeInBytes = bufferWidth * bufferHeight * bytesPerPixel;
if (_DataSizeInBytes < newSizeInBytes)
{
_DataSizeInBytes = newSizeInBytes;
_data.Dispose();
IntPtr nativeBuff = System.Runtime.InteropServices.Marshal.AllocHGlobal(_DataSizeInBytes);
_data = new TempMemPtr(nativeBuff, _DataSizeInBytes);
}
_buf = new PixelProcessing.SubBitmapBlender(_data, 0, bufferWidth, bufferHeight, bufferWidth * bytesPerPixel, src.BitDepth, bytesPerPixel);
unsafe
{
using (TempMemPtr destMemPtr = _buf.GetBufferPtr())
using (TempMemPtr srcMemPtr = src.GetBufferPtr())
{
int *destBuffer = (int *)destMemPtr.Ptr;
int *srcBuffer = (int *)srcMemPtr.Ptr;
// copy the image into the middle of the dest
for (int y = 0; y < _height; y++)
{
for (int x = 0; x < _width; x++)
{
int sourceOffset = src.GetBufferOffsetXY32(x, y);
int destOffset = _buf.GetBufferOffsetXY32(_dilation, y + _dilation);
destBuffer[destOffset] = srcBuffer[sourceOffset];
}
}
// copy the first two pixels form the end into the begining and from the begining into the end
for (int y = 0; y < _height; y++)
{
int s1Offset = src.GetBufferOffsetXY32(0, y);
int d1Offset = _buf.GetBufferOffsetXY32(_dilation + _width, y);
int s2Offset = src.GetBufferOffsetXY32(_width - _dilation, y);
int d2Offset = _buf.GetBufferOffsetXY32(0, y);
for (int x = 0; x < _dilation; x++)
{
destBuffer[d1Offset++] = srcBuffer[s1Offset++];
destBuffer[d2Offset++] = srcBuffer[s2Offset++];
}
}
}
}
}
// Create
//--------------------------------------------------------------------
public void Create(IBitmapSrc src)
{
// we are going to create a dialated image for filtering
// we add m_dilation pixels to every side of the image and then copy the image in the x
// dirrection into each end so that we can sample into this image to get filtering on x repeating
// if the original image look like this
//
// 123456
//
// the new image would look like this
//
// 0000000000
// 0000000000
// 5612345612
// 0000000000
// 0000000000
m_height = (int)AggMath.uceil(src.Height);
m_width = (int)AggMath.uceil(src.Width);
m_width_hr = (int)AggMath.uround(src.Width * LineAA.SUBPIXEL_SCALE);
m_half_height_hr = (int)AggMath.uround(src.Height * LineAA.SUBPIXEL_SCALE / 2);
m_offset_y_hr = m_dilation_hr + m_half_height_hr - LineAA.SUBPIXEL_SCALE / 2;
m_half_height_hr += LineAA.SUBPIXEL_SCALE / 2;
int bufferWidth = m_width + m_dilation * 2;
int bufferHeight = m_height + m_dilation * 2;
int bytesPerPixel = src.BitDepth / 8;
int newSizeInBytes = bufferWidth * bufferHeight * bytesPerPixel;
if (m_DataSizeInBytes < newSizeInBytes)
{
m_DataSizeInBytes = newSizeInBytes;
m_data = new int[m_DataSizeInBytes / 4];
}
m_buf = new PixelProcessing.SubBitmapBlender(m_data, 0, bufferWidth, bufferHeight, bufferWidth * bytesPerPixel, src.BitDepth, bytesPerPixel);
unsafe
{
CpuBlit.Imaging.TempMemPtr destMemPtr = m_buf.GetBufferPtr();
CpuBlit.Imaging.TempMemPtr srcMemPtr = src.GetBufferPtr();
int *destBuffer = (int *)destMemPtr.Ptr;
int *srcBuffer = (int *)srcMemPtr.Ptr;
// copy the image into the middle of the dest
for (int y = 0; y < m_height; y++)
{
for (int x = 0; x < m_width; x++)
{
int sourceOffset = src.GetBufferOffsetXY32(x, y);
int destOffset = m_buf.GetBufferOffsetXY32(m_dilation, y + m_dilation);
destBuffer[destOffset] = srcBuffer[sourceOffset];
}
}
// copy the first two pixels form the end into the begining and from the begining into the end
for (int y = 0; y < m_height; y++)
{
int s1Offset = src.GetBufferOffsetXY32(0, y);
int d1Offset = m_buf.GetBufferOffsetXY32(m_dilation + m_width, y);
int s2Offset = src.GetBufferOffsetXY32(m_width - m_dilation, y);
int d2Offset = m_buf.GetBufferOffsetXY32(0, y);
for (int x = 0; x < m_dilation; x++)
{
destBuffer[d1Offset++] = srcBuffer[s1Offset++];
destBuffer[d2Offset++] = srcBuffer[s2Offset++];
}
}
srcMemPtr.Release();
destMemPtr.Release();
}
}
