public span_subdiv_adaptor(ISpanInterpolator interpolator, int subdiv_shift)
{
m_subdiv_shift = subdiv_shift;
m_subdiv_size = 1 << m_subdiv_shift;
m_subdiv_mask = m_subdiv_size - 1;
m_interpolator = interpolator;
}
public SpanSubDivAdaptor(ISpanInterpolator <T> interpolator,
T x, T y, uint len,
int subdiv_shift)
: this(interpolator, subdiv_shift)
{
Begin(x, y, len);
}
public override void GenerateColors(ColorRGBA[] outputColors, int startIndex, int x, int y, int len)
{
ISpanInterpolator spanInterpolator = Interpolator;
spanInterpolator.Begin(x + dx, y + dy, len);
int x_hr;
int y_hr;
spanInterpolator.GetCoord(out x_hr, out y_hr);
int x_lr = x_hr >> img_subpix_const.SHIFT;
int y_lr = y_hr >> img_subpix_const.SHIFT;
int bufferIndex = srcRW.GetBufferOffsetXY(x_lr, y_lr);
byte[] srcBuff = srcRW.GetBuffer();
ColorRGBA color = ColorRGBA.White;
do
{
color.blue = srcBuff[bufferIndex++];
color.green = srcBuff[bufferIndex++];
color.red = srcBuff[bufferIndex++];
outputColors[startIndex++] = color;
} while (--len != 0);
}
public SpanSubdivisionAdaptor(ISpanInterpolator interpolator, int subdiv_shift)
{
m_subdiv_shift = subdiv_shift;
m_subdiv_size = 1 << m_subdiv_shift;
m_subdiv_mask = m_subdiv_size - 1;
m_interpolator = interpolator;
}
public override void GenerateColors(ColorRGBA[] outputColors, int startIndex, int x, int y, int len)
{
ISpanInterpolator spanInterpolator = Interpolator;
spanInterpolator.Begin(x + dx, y + dy, len);
int x_hr;
int y_hr;
spanInterpolator.GetCoord(out x_hr, out y_hr);
int x_lr = x_hr >> img_subpix_const.SHIFT;
int y_lr = y_hr >> img_subpix_const.SHIFT;
int bufferIndex = srcRW.GetBufferOffsetXY(x_lr, y_lr);
byte[] srcBuffer = srcRW.GetBuffer();
unsafe
{
fixed(byte *pSource = srcBuffer)
{
do
{
outputColors[startIndex++] = *(ColorRGBA *)&(pSource[bufferIndex]);
bufferIndex += 4;
} while (--len != 0);
}
}
}
public span_subdiv_adaptor(ISpanInterpolator interpolator,
double x, double y, int len,
int subdiv_shift)
: this(interpolator, subdiv_shift)
{
begin(x, y, len);
}
public unsafe override void Generate(RGBA_Bytes *span, int x, int y, uint len)
{
RasterBuffer pSourceRenderingBuffer = base.Source().PixelFormat.GetRenderingBuffer();
ISpanInterpolator <T> spanInterpolator = base.Interpolator;
spanInterpolator.Begin(M.New <T>(x).Add(base.FilterDxDbl()), M.New <T>(y).Add(base.FilterDyDbl()), len);
do
{
int x_hr;
int y_hr;
spanInterpolator.Coordinates(out x_hr, out y_hr);
int x_lr = x_hr >> (int)image_subpixel_scale_e.Shift;
int y_lr = y_hr >> (int)image_subpixel_scale_e.Shift;
byte *fg_ptr = pSourceRenderingBuffer.GetPixelPointer(y_lr) + (x_lr << 2);
//byte* fg_ptr = spanInterpolator.span(x_lr, y_lr, 1);
//(*span).R = fg_ptr[OrderR];
//(*span).G = fg_ptr[OrderG];
//(*span).B = fg_ptr[OrderB];
//(*span).A = fg_ptr[OrderA];
(*span) = new RGBA_Bytes(fg_ptr[OrderR], fg_ptr[OrderG], fg_ptr[OrderB], fg_ptr[OrderA]);
++span;
spanInterpolator.Next();
} while (--len != 0);
}
public override void GenerateColors(ColorRGBA[] outputColors, int startIndex, int x, int y, int len)
{
int bytesBetweenPixelsInclusive = srcRW.BytesBetweenPixelsInclusive;
ISpanInterpolator spanInterpolator = Interpolator;
spanInterpolator.Begin(x + dx, y + dy, len);
int x_hr;
int y_hr;
spanInterpolator.GetCoord(out x_hr, out y_hr);
int x_lr = x_hr >> img_subpix_const.SHIFT;
int y_lr = y_hr >> img_subpix_const.SHIFT;
int bufferIndex;
bufferIndex = srcRW.GetBufferOffsetXY(x_lr, y_lr);
byte[] srcBuff = srcRW.GetBuffer();
unsafe
{
fixed(byte *pSource = srcBuff)
{
do
{
outputColors[startIndex].red = pSource[bufferIndex];
outputColors[startIndex].green = pSource[bufferIndex];
outputColors[startIndex].blue = pSource[bufferIndex];
outputColors[startIndex].alpha = 255;
startIndex++;
bufferIndex += bytesBetweenPixelsInclusive;
} while (--len != 0);
}
}
}
public SpanSubdivisionAdaptor(ISpanInterpolator interpolator, int subdiv_shift)
{
m_subdiv_shift = subdiv_shift;
m_subdiv_size = 1 << m_subdiv_shift;
m_subdiv_mask = m_subdiv_size - 1;
m_interpolator = interpolator;
}
public override void generate(RGBA_Bytes[] span, int spanIndex, int x, int y, int len)
{
ImageBuffer SourceRenderingBuffer = (ImageBuffer)GetImageBufferAccessor().SourceImage;
if (SourceRenderingBuffer.BitDepth != 24)
{
throw new NotSupportedException("The source is expected to be 32 bit.");
}
ISpanInterpolator spanInterpolator = interpolator();
spanInterpolator.begin(x + filter_dx_dbl(), y + filter_dy_dbl(), len);
int offset;
byte[] fg_ptr = SourceRenderingBuffer.GetBuffer(out offset);
do
{
int x_hr;
int y_hr;
spanInterpolator.coordinates(out x_hr, out y_hr);
int x_lr = x_hr >> (int)image_subpixel_scale_e.image_subpixel_shift;
int y_lr = y_hr >> (int)image_subpixel_scale_e.image_subpixel_shift;
int bufferIndex;
bufferIndex = SourceRenderingBuffer.GetBufferOffsetXY(x_lr, y_lr);
RGBA_Bytes color;
color.blue = fg_ptr[bufferIndex++];
color.green = fg_ptr[bufferIndex++];
color.red = fg_ptr[bufferIndex++];
color.alpha = 255;
span[spanIndex] = color;
spanIndex++;
spanInterpolator.Next();
} while (--len != 0);
}
public span_subdiv_adaptor(ISpanInterpolator interpolator,
double x, double y, int len,
int subdiv_shift)
: this(interpolator, subdiv_shift)
{
begin(x, y, len);
}
public SpanSubdivisionAdaptor(ISpanInterpolator interpolator,
double x, double y, uint len,
int subdiv_shift)
: this(interpolator, subdiv_shift)
{
Begin(x, y, len);
}
public span_subdiv_adaptor(ISpanInterpolator interpolator, int subdiv_shift)
{
m_subdiv_shift = subdiv_shift;
m_subdiv_size = 1 << m_subdiv_shift;
m_subdiv_mask = m_subdiv_size - 1;
m_interpolator = interpolator;
}
public SpanSubdivisionAdaptor(ISpanInterpolator interpolator,
double x, double y, uint len,
int subdiv_shift)
: this(interpolator, subdiv_shift)
{
Begin(x, y, len);
}
//--------------------------------------------------------------------
public span_image_filter_rgb_bilinear_clip(IImageBufferAccessor src,
IColorType back_color,
ISpanInterpolator inter)
: base(src, inter, null)
{
m_OutsideSourceColor = back_color.GetAsRGBA_Bytes();
}
//--------------------------------------------------------------------
public ImgSpanGenRGB_BilinearClip(IImageReaderWriter src,
ColorRGBA back_color,
ISpanInterpolator inter)
: base(inter)
{
m_bgcolor = back_color;
srcRW = (ImageReaderWriterBase)src;
}
public ImgSpanGen(ISpanInterpolator interpolator)
{
m_interpolator = interpolator;
m_dx_dbl = 0.5;
m_dy_dbl = 0.5;
m_dx_int = (img_subpix_const.SCALE / 2);
m_dy_int = (img_subpix_const.SCALE / 2);
}
//--------------------------------------------------------------------
public span_image_filter_rgb_2x2(IRasterBufferAccessor src, ISpanInterpolator inter, ImageFilterLookUpTable filter)
: base(src, inter, filter)
{
OrderR = src.PixelFormat.Blender.OrderR;
OrderG = src.PixelFormat.Blender.OrderG;
OrderB = src.PixelFormat.Blender.OrderB;
OrderA = src.PixelFormat.Blender.OrderA;
}
//--------------------------------------------------------------------
public span_image_filter_rgb(IImageBufferAccessor src, ISpanInterpolator inter, ImageFilterLookUpTable filter)
: base(src, inter, filter)
{
if (src.SourceImage.GetBytesBetweenPixelsInclusive() != 3)
{
throw new System.NotSupportedException("span_image_filter_rgb must have a 24 bit DestImage");
}
}
//--------------------------------------------------------------------
public ImgSpanGenRGB_BilinearClip(IImageReaderWriter src,
Drawing.Color back_color,
ISpanInterpolator inter)
: base(inter)
{
m_bgcolor = back_color;
srcRW = (ImageReaderWriterBase)src;
}
public SpanImageFilterRGBABilinear(IRasterBufferAccessor src, ISpanInterpolator inter)
: base(src, inter, null)
{
OrderR = src.PixelFormat.Blender.OrderR;
OrderG = src.PixelFormat.Blender.OrderG;
OrderB = src.PixelFormat.Blender.OrderB;
OrderA = src.PixelFormat.Blender.OrderA;
}
public SpanImageFilterRGBABilinear(IRasterBufferAccessor src, ISpanInterpolator inter)
: base(src, inter, null)
{
OrderR = src.PixelFormat.Blender.OrderR;
OrderG = src.PixelFormat.Blender.OrderG;
OrderB = src.PixelFormat.Blender.OrderB;
OrderA = src.PixelFormat.Blender.OrderA;
}
//--------------------------------------------------------------------
public SpanImageFilterRgb2x2(IRasterBufferAccessor src, ISpanInterpolator <T> inter, ImageFilterLookUpTable <T> filter)
: base(src, inter, filter)
{
OrderR = src.PixelFormat.Blender.OrderR;
OrderG = src.PixelFormat.Blender.OrderG;
OrderB = src.PixelFormat.Blender.OrderB;
OrderA = src.PixelFormat.Blender.OrderA;
}
public ImgSpanGen(ISpanInterpolator interpolator)
{
m_interpolator = interpolator;
m_dx_dbl = 0.5;
m_dy_dbl = 0.5;
m_dx_int = (img_subpix_const.SCALE / 2);
m_dy_int = (img_subpix_const.SCALE / 2);
}
//--------------------------------------------------------------------
public span_image_filter_rgb_nn(IRasterBufferAccessor src, ISpanInterpolator inter)
: base(src, inter, null)
{
OrderR = src.PixelFormat.Blender.OrderR;
OrderG = src.PixelFormat.Blender.OrderG;
OrderB = src.PixelFormat.Blender.OrderB;
OrderA = src.PixelFormat.Blender.OrderA;
}
public SpanImageResample(IRasterBufferAccessor src,
ISpanInterpolator inter,
ImageFilterLookUpTable filter) : base(src, inter, filter)
{
m_scale_limit = (20);
m_blur_x = ((int)image_subpixel_scale_e.Scale);
m_blur_y = ((int)image_subpixel_scale_e.Scale);
}
public ImgSpanGenGray_NNStepXby1(IImageReaderWriter src, ISpanInterpolator spanInterpolator)
: base(spanInterpolator)
{
srcRW = (ImageReaderWriterBase)src;
if (srcRW.BitDepth != 8)
{
throw new NotSupportedException("The source is expected to be 32 bit.");
}
}
public ImgSpanGenRGBA_NN_StepXBy1(IBitmapSrc src, ISpanInterpolator spanInterpolator)
: base(spanInterpolator)
{
_bmpSrc = src;
if (_bmpSrc.BitDepth != 32)
{
throw new NotSupportedException("The source is expected to be 32 bit.");
}
}
public SpanImageFilterRGBABilinearClip(IRasterBufferAccessor src,
IColorType back_color, ISpanInterpolator inter) : base(src, inter, null)
{
m_back_color = back_color.GetAsRGBA_Bytes();
OrderR = src.PixelFormat.Blender.OrderR;
OrderG = src.PixelFormat.Blender.OrderG;
OrderB = src.PixelFormat.Blender.OrderB;
OrderA = src.PixelFormat.Blender.OrderA;
}
public ImgSpanGenRGBA_BilinearClip(IBitmapSrc src,
Drawing.Color back_color,
ISpanInterpolator inter)
: base(inter)
{
m_bgcolor = back_color;
_imgsrc = src;
bytesBetweenPixelInclusive = _imgsrc.BytesBetweenPixelsInclusive;
}
public ImgSpanGenGray_NNStepXby1(IImageReaderWriter src, ISpanInterpolator spanInterpolator)
: base(spanInterpolator)
{
srcRW = (ImageReaderWriterBase)src;
if (srcRW.BitDepth != 8)
{
throw new NotSupportedException("The source is expected to be 32 bit.");
}
}
public ImgSpanGenRGBA_BilinearClip(IImageReaderWriter src,
ColorRGBA back_color,
ISpanInterpolator inter)
: base(inter)
{
m_bgcolor = back_color;
srcRW = (ImageReaderWriterBase)src;
bytesBetweenPixelInclusive = srcRW.BytesBetweenPixelsInclusive;
}
//--------------------------------------------------------------------
public span_image_resample_rgb(IImageBufferAccessor src,
ISpanInterpolator inter,
ImageFilterLookUpTable filter) :
base(src, inter, filter)
{
if (src.SourceImage.GetRecieveBlender().NumPixelBits != 24)
{
throw new System.FormatException("You have to use a rgb blender with span_image_resample_rgb");
}
}
//--------------------------------------------------------------------
public FilterRGBImageSpanGen(IImageReaderWriter src,
ISpanInterpolator inter,
ImageFilterLookUpTable filter) :
base(src, inter, filter)
{
if (src.GetRecieveBlender().NumPixelBits != 24)
{
throw new System.FormatException("You have to use a rgb blender with span_image_resample_rgb");
}
}
public static void SubPixTranslateBeginCoord(this ISpanInterpolator interpolator,
double inX, double inY,
out int outX, out int outY)
{
interpolator.Begin(inX, inY, 1);
interpolator.GetCoord(out int x_hr, out int y_hr);
//get translate version
outX = x_hr >> subpix_const.SHIFT;
outY = y_hr >> subpix_const.SHIFT;
}
public override void Prepare()
{
base.Prepare();
ISpanInterpolator spanInterpolator = base.Interpolator;
_mode0 = (spanInterpolator.GetType() == typeof(PixelFarm.Agg.Transform.SpanInterpolatorLinear) &&
((PixelFarm.Agg.Transform.SpanInterpolatorLinear)spanInterpolator).Transformer.GetType() == typeof(PixelFarm.Agg.Transform.Affine) &&
((PixelFarm.Agg.Transform.Affine)((PixelFarm.Agg.Transform.SpanInterpolatorLinear)spanInterpolator).Transformer).IsIdentity());
}
public override void Prepare()
{
base.Prepare();
ISpanInterpolator spanInterpolator = base.Interpolator;
_mode0 = (spanInterpolator.GetType() == typeof(SpanInterpolatorLinear) &&
((SpanInterpolatorLinear)spanInterpolator).Transformer.GetType() == typeof(VertexProcessing.Affine) &&
((VertexProcessing.Affine)((SpanInterpolatorLinear)spanInterpolator).Transformer).IsIdentity());
}
//--------------------------------------------------------------------
public FilterRGBAImageSpanGen(IImageReaderWriter src,
ISpanInterpolator inter,
ImageFilterLookUpTable filter) :
base(src, inter, filter)
{
if (src.GetRecieveBlender().NumPixelBits != 32)
{
throw new System.FormatException("You have to use a rgba blender with span_image_resample_rgba");
}
}
//--------------------------------------------------------------------
public span_gradient(ISpanInterpolator inter,
IGradient gradient_function,
IColorFunction color_function,
double d1, double d2)
{
m_interpolator = inter;
m_gradient_function = gradient_function;
m_color_function = color_function;
m_d1 = (agg_basics.iround(d1 * gradient_subpixel_scale));
m_d2 = (agg_basics.iround(d2 * gradient_subpixel_scale));
}
public SpanImageFilter(IRasterBufferAccessor src,
ISpanInterpolator interpolator, ImageFilterLookUpTable filter)
{
m_src = src;
m_interpolator = interpolator;
m_filter = (filter);
m_dx_dbl = (0.5);
m_dy_dbl = (0.5);
m_dx_int = ((int)image_subpixel_scale_e.Scale / 2);
m_dy_int = ((int)image_subpixel_scale_e.Scale / 2);
}
public span_image_filter(IImageBufferAccessor src,
ISpanInterpolator interpolator, ImageFilterLookUpTable filter)
{
imageBufferAccessor = src;
m_interpolator = interpolator;
m_filter = (filter);
m_dx_dbl = (0.5);
m_dy_dbl = (0.5);
m_dx_int = ((int)image_subpixel_scale_e.image_subpixel_scale / 2);
m_dy_int = ((int)image_subpixel_scale_e.image_subpixel_scale / 2);
}
//--------------------------------------------------------------------
public span_gradient(ISpanInterpolator inter,
IGradient gradient_function,
IColorFunction color_function,
double d1, double d2)
{
m_interpolator = inter;
m_gradient_function = gradient_function;
m_color_function = color_function;
m_d1 = (agg_basics.iround(d1 * gradient_subpixel_scale));
m_d2 = (agg_basics.iround(d2 * gradient_subpixel_scale));
}
public FilterImageSpanGenerator(IImageReaderWriter src,
ISpanInterpolator inter,
ImageFilterLookUpTable filterLookup)
: base(inter)
{
this.imageBufferAccessor = new ImageBufferAccessor(src);
m_scale_limit = 20;
//m_blur_x = ((int)img_subpix_scale.SCALE);
//m_blur_y = ((int)img_subpix_scale.SCALE);
this.filterLookup = filterLookup;
}
//--------------------------------------------------------------------
public SpanGenGradient(ISpanInterpolator inter,
IGradientValueCalculator gvc,
IGradientColorsProvider m_colorsProvider,
double d1, double d2)
{
this.m_interpolator = inter;
this.m_grValueCalculator = gvc;
this.m_colorsProvider = m_colorsProvider;
m_d1 = AggBasics.iround(d1 * GR_SUBPIX_SCALE);
m_d2 = AggBasics.iround(d2 * GR_SUBPIX_SCALE);
dd = m_d2 - m_d1;
if (dd < 1) dd = 1;
stepRatio = (float)m_colorsProvider.GradientSteps / (float)dd;
}
//--------------------------------------------------------------------
public span_image_filter_rgb_nn(IRasterBufferAccessor src, ISpanInterpolator inter)
: base(src, inter, null)
{
OrderR = src.PixelFormat.Blender.OrderR;
OrderG = src.PixelFormat.Blender.OrderG;
OrderB = src.PixelFormat.Blender.OrderB;
OrderA = src.PixelFormat.Blender.OrderA;
}
//--------------------------------------------------------------------
public span_image_filter_rgb_2x2(IImageBufferAccessor src, ISpanInterpolator inter, ImageFilterLookUpTable filter)
: base(src, inter, filter)
{
}
public SpanImageResample(IRasterBufferAccessor src,
ISpanInterpolator inter,
ImageFilterLookUpTable filter)
: base(src, inter, filter)
{
m_scale_limit = (20);
m_blur_x = ((int)image_subpixel_scale_e.Scale);
m_blur_y = ((int)image_subpixel_scale_e.Scale);
}
//--------------------------------------------------------------------
public span_image_resample_rgba(IImageBufferAccessor src,
ISpanInterpolator inter,
ImageFilterLookUpTable filter) :
base(src, inter, filter)
{
if (src.DestImage.GetBlender().NumPixelBits != 32)
{
throw new System.FormatException("You have to use a rgba blender with span_image_resample_rgba");
}
}
public span_image_filter(IImageBufferAccessor src,
ISpanInterpolator interpolator)
: this(src, interpolator, null)
{
}
//--------------------------------------------------------------------
public span_image_filter_rgb(IImageBufferAccessor src, ISpanInterpolator inter, ImageFilterLookUpTable filter)
: base(src, inter, filter)
{
if (src.SourceImage.GetBytesBetweenPixelsInclusive() != 3)
{
throw new System.NotSupportedException("span_image_filter_rgb must have a 24 bit DestImage");
}
}
public span_image_filter_rgba_bilinear_clip(IImageBufferAccessor src,
IColorType back_color, ISpanInterpolator inter)
: base(src, inter, null)
{
m_OutsideSourceColor = back_color.GetAsRGBA_Bytes();
}
//--------------------------------------------------------------------
public SpanImageResampleRGB(IRasterBufferAccessor src,
ISpanInterpolator inter,
ImageFilterLookUpTable filter)
: base(src, inter, filter)
{
if (src.PixelFormat.Blender.NumPixelBits != 24)
{
throw new System.FormatException("You have to use a rgb blender with SpanImageResampleRGB");
}
OrderR = src.PixelFormat.Blender.OrderR;
OrderG = src.PixelFormat.Blender.OrderG;
OrderB = src.PixelFormat.Blender.OrderB;
}
public span_image_filter_rgba_bilinear(IImageBufferAccessor src, ISpanInterpolator inter)
: base(src, inter, null)
{
}
//--------------------------------------------------------------------
public span_image_filter_rgb(IRasterBufferAccessor src, ISpanInterpolator inter, ImageFilterLookUpTable filter)
: base(src, inter, filter)
{
if (src.PixelFormat.PixelWidthInBytes != 3)
{
throw new System.NotSupportedException("span_image_filter_rgb must have a 24 bit PixelFormat");
}
OrderR = src.PixelFormat.Blender.OrderR;
OrderG = src.PixelFormat.Blender.OrderG;
OrderB = src.PixelFormat.Blender.OrderB;
OrderA = src.PixelFormat.Blender.OrderA;
}
//--------------------------------------------------------------------
public void interpolator(ISpanInterpolator v)
{
m_interpolator = v;
}
//--------------------------------------------------------------------
public span_image_filter_rgb_2x2(IRasterBufferAccessor src, ISpanInterpolator inter, ImageFilterLookUpTable filter)
: base(src, inter, filter)
{
OrderR = src.PixelFormat.Blender.OrderR;
OrderG = src.PixelFormat.Blender.OrderG;
OrderB = src.PixelFormat.Blender.OrderB;
OrderA = src.PixelFormat.Blender.OrderA;
}
public SpanImageFilter(IRasterBufferAccessor src,
ISpanInterpolator interpolator)
: this(src, interpolator, null)
{
}
//--------------------------------------------------------------------
public span_image_filter_rgb_bilinear_clip(IRasterBufferAccessor src,
IColorType back_color,
ISpanInterpolator inter)
: base(src, inter, null)
{
m_back_color = back_color.GetAsRGBA_Bytes();
OrderR = src.PixelFormat.Blender.OrderR;
OrderG = src.PixelFormat.Blender.OrderG;
OrderB = src.PixelFormat.Blender.OrderB;
OrderA = src.PixelFormat.Blender.OrderA;
}
public span_image_filter_gray_nn_stepXby1(IImageBufferAccessor sourceAccessor, ISpanInterpolator spanInterpolator)
: base(sourceAccessor, spanInterpolator, null)
{
}
//----------------------------------------------------------------
public SpanSubdivisionAdaptor(ISpanInterpolator interpolator)
: this(interpolator, 4)
{
}
