public void Render(IBitmapSrc source, double destX, double destY)
{
int inScaleX = 1;
int inScaleY = 1;
int angleRadians = 0;
// exit early if the dest and source bounds don't touch.
// TODO: <BUG> make this do rotation and scalling
RectInt sourceBounds = new RectInt((int)destX, (int)destY, (int)destX + source.Width, (int)destY + source.Height);
//sourceBounds.Offset((int)destX, (int)destY);
RectInt destBounds = _destBitmapBlender.GetBounds();
if (!RectInt.DoIntersect(sourceBounds, destBounds))
{
//if (inScaleX != 1 || inScaleY != 1 || angleRadians != 0)
//{
// throw new NotImplementedException();
//}
return;
}
double scaleX = inScaleX;
double scaleY = inScaleY;
ICoordTransformer graphicsTransform = this.CurrentTransformMatrix;
if (!graphicsTransform.IsIdentity)
{
if (scaleX != 1 || scaleY != 1 || angleRadians != 0)
{
throw new NotImplementedException();
}
graphicsTransform.Transform(ref destX, ref destY);
}
#if false // this is an optomization that eliminates the drawing of images that have their alpha set to all 0 (happens with generated images like explosions).
MaxAlphaFrameProperty maxAlphaFrameProperty = MaxAlphaFrameProperty::GetMaxAlphaFrameProperty(source);
if ((maxAlphaFrameProperty.GetMaxAlpha() * color.A_Byte) / 256 <= ALPHA_CHANNEL_BITS_DIVISOR)
{
m_OutFinalBlitBounds.SetRect(0, 0, 0, 0);
}
#endif
bool isScale = (scaleX != 1 || scaleY != 1);
bool isRotated = false;
if (angleRadians != 0 && Math.Abs(angleRadians) >= (0.1 * MathHelper.Tau / 360))
{
isRotated = true;
}
else
{
angleRadians = 0;//reset very small angle to 0
}
//bool IsMipped = false;
//double ox, oy;
//source.GetOriginOffset(out ox, out oy);
bool canUseMipMaps = isScale;
if (scaleX > 0.5 || scaleY > 0.5)
{
canUseMipMaps = false;
}
bool needSourceResampling = isScale || isRotated;// || destX != (int)destX || destY != (int)destY;
//VectorToolBox.GetFreeVxs(out VertexStore imgBoundsPath);
// this is the fast drawing path
if (needSourceResampling)
{
#if false // if the scalling is small enough the results can be improved by using mip maps
if (CanUseMipMaps)
{
CMipMapFrameProperty *pMipMapFrameProperty = CMipMapFrameProperty::GetMipMapFrameProperty(source);
double OldScaleX = scaleX;
double OldScaleY = scaleY;
const CFrameInterface *pMippedFrame = pMipMapFrameProperty.GetMipMapFrame(ref scaleX, ref scaleY);
if (pMippedFrame != source)
{
IsMipped = true;
source = pMippedFrame;
sourceOriginOffsetX *= (OldScaleX / scaleX);
sourceOriginOffsetY *= (OldScaleY / scaleY);
}
HotspotOffsetX *= (inScaleX / scaleX);
HotspotOffsetY *= (inScaleY / scaleY);
}
#endif
using (VxsTemp.Borrow(out var imgBoundsPath, out var v1))
{
BuildOrgImgRectVxs(source.Width, source.Height, imgBoundsPath);
Affine destRectTransform = CreateAffine(destX, destY, _ox, _oy, scaleX, scaleY, angleRadians);
//TODO: review reusable span generator an interpolator ***
// We invert it because it is the transform to make the image go to the same position as the polygon. LBB [2/24/2004]
//spanInterpolator.Transformer = destRectTransform.CreateInvert();
//var imgSpanGen = new ImgSpanGenRGBA_BilinearClip(
// Drawing.Color.Black,
// spanInterpolator);
_spanInterpolator.Transformer = destRectTransform.CreateInvert();
_currentImgSpanGen.SetInterpolator(_spanInterpolator);
_currentImgSpanGen.SetSrcBitmap(source);
destRectTransform.TransformToVxs(imgBoundsPath, v1);
Render(v1, _currentImgSpanGen);
_currentImgSpanGen.ReleaseSrcBitmap();
}
////Affine destRectTransform = BuildImageBoundsPath(source.Width, source.Height,
//// destX, destY, ox, oy, scaleX, scaleY, angleRadians, imgBoundsPath);
//Affine destRectTransform = CreateAffine(destX, destY, ox, oy, scaleX, scaleY, angleRadians);
////TODO: review reusable span generator an interpolator ***
//var spanInterpolator = new SpanInterpolatorLinear();
//// We invert it because it is the transform to make the image go to the same position as the polygon. LBB [2/24/2004]
//spanInterpolator.Transformer = destRectTransform.CreateInvert();
//var imgSpanGen = new ImgSpanGenRGBA_BilinearClip(
// source,
// Drawing.Color.Black,
// spanInterpolator);
//VectorToolBox.GetFreeVxs(out VertexStore v1);
//destRectTransform.TransformToVxs(imgBoundsPath, v1);
//Render(v1, imgSpanGen);
//VectorToolBox.ReleaseVxs(ref v1);
#if false // this is some debug you can enable to visualize the dest bounding box
LineFloat(BoundingRect.left, BoundingRect.top, BoundingRect.right, BoundingRect.top, WHITE);
LineFloat(BoundingRect.right, BoundingRect.top, BoundingRect.right, BoundingRect.bottom, WHITE);
LineFloat(BoundingRect.right, BoundingRect.bottom, BoundingRect.left, BoundingRect.bottom, WHITE);
LineFloat(BoundingRect.left, BoundingRect.bottom, BoundingRect.left, BoundingRect.top, WHITE);
#endif
}
else // TODO: this can be even faster if we do not use an intermediate buffer
{
//Affine destRectTransform = BuildImageBoundsPath(
// source.Width, source.Height,
// destX, destY, imgBoundsPath);
using (VxsTemp.Borrow(out var imgBoundsPath, out var v1))
{
BuildOrgImgRectVxs(source.Width, source.Height, imgBoundsPath);
//...
Affine destRectTransform = CreateAffine(destX, destY);
//TODO: review reusable span generator an interpolator ***
// We invert it because it is the transform to make the image go to the same position as the polygon. LBB [2/24/2004]
_spanInterpolator.Transformer = destRectTransform.CreateInvert();
//we generate image by this imagespan generator
ImgSpanGen imgSpanGen = null;
switch (source.BitDepth)
{
case 32:
if (_imgSpanGenCustom != null)
{
//use custom span gen
_imgSpanGenCustom.SetInterpolator(_spanInterpolator);
_imgSpanGenCustom.SetSrcBitmap(source);
imgSpanGen = _imgSpanGenCustom;
}
else
{
_imgSpanGenNNStepXBy1.SetInterpolator(_spanInterpolator);
_imgSpanGenNNStepXBy1.SetSrcBitmap(source);
imgSpanGen = _imgSpanGenNNStepXBy1;
}
break;
//case 8:
// imgSpanGen = new ImgSpanGenGray_NNStepXby1(source, interpolator);
// break;
default:
throw new NotImplementedException();
}
destRectTransform.TransformToVxs(imgBoundsPath, v1);
//...
Render(v1, imgSpanGen);
}
//
unchecked { _destImageChanged++; };
}
}
public void Render(IImageReaderWriter source,
double destX, double destY,
double angleRadians,
double inScaleX, double inScaleY)
{
{ // exit early if the dest and source bounds don't touch.
// TODO: <BUG> make this do rotation and scalling
RectInt sourceBounds = source.GetBounds();
RectInt destBounds = this.destImageReaderWriter.GetBounds();
sourceBounds.Offset((int)destX, (int)destY);
if (!RectInt.DoIntersect(sourceBounds, destBounds))
{
if (inScaleX != 1 || inScaleY != 1 || angleRadians != 0)
{
throw new NotImplementedException();
}
return;
}
}
double scaleX = inScaleX;
double scaleY = inScaleY;
Affine graphicsTransform = this.CurrentTransformMatrix;
if (!graphicsTransform.IsIdentity())
{
if (scaleX != 1 || scaleY != 1 || angleRadians != 0)
{
throw new NotImplementedException();
}
graphicsTransform.Transform(ref destX, ref destY);
}
#if false // this is an optomization that eliminates the drawing of images that have their alpha set to all 0 (happens with generated images like explosions).
MaxAlphaFrameProperty maxAlphaFrameProperty = MaxAlphaFrameProperty::GetMaxAlphaFrameProperty(source);
if ((maxAlphaFrameProperty.GetMaxAlpha() * color.A_Byte) / 256 <= ALPHA_CHANNEL_BITS_DIVISOR)
{
m_OutFinalBlitBounds.SetRect(0, 0, 0, 0);
}
#endif
bool isScale = (scaleX != 1 || scaleY != 1);
bool isRotated = true;
if (Math.Abs(angleRadians) < (0.1 * MathHelper.Tau / 360))
{
isRotated = false;
angleRadians = 0;
}
//bool IsMipped = false;
//double ox, oy;
//source.GetOriginOffset(out ox, out oy);
bool canUseMipMaps = isScale;
if (scaleX > 0.5 || scaleY > 0.5)
{
canUseMipMaps = false;
}
bool renderRequriesSourceSampling = isScale || isRotated || destX != (int)destX || destY != (int)destY;
VectorToolBox.GetFreeVxs(out VertexStore imgBoundsPath);
// this is the fast drawing path
if (renderRequriesSourceSampling)
{
// if the scalling is small enough the results can be improved by using mip maps
//if(CanUseMipMaps)
//{
// CMipMapFrameProperty* pMipMapFrameProperty = CMipMapFrameProperty::GetMipMapFrameProperty(source);
// double OldScaleX = scaleX;
// double OldScaleY = scaleY;
// const CFrameInterface* pMippedFrame = pMipMapFrameProperty.GetMipMapFrame(ref scaleX, ref scaleY);
// if(pMippedFrame != source)
// {
// IsMipped = true;
// source = pMippedFrame;
// sourceOriginOffsetX *= (OldScaleX / scaleX);
// sourceOriginOffsetY *= (OldScaleY / scaleY);
// }
// HotspotOffsetX *= (inScaleX / scaleX);
// HotspotOffsetY *= (inScaleY / scaleY);
//}
Affine destRectTransform = BuildImageBoundsPath(source.Width, source.Height,
destX, destY, ox, oy, scaleX, scaleY, angleRadians, imgBoundsPath);
// We invert it because it is the transform to make the image go to the same position as the polygon. LBB [2/24/2004]
Affine sourceRectTransform = destRectTransform.CreateInvert();
var interpolator = new SpanInterpolatorLinear(sourceRectTransform);
var imgSpanGen = new ImgSpanGenRGBA_BilinearClip(source, Drawing.Color.Black, interpolator);
VectorToolBox.GetFreeVxs(out var v1);
destRectTransform.TransformToVxs(imgBoundsPath, v1);
Render(v1, imgSpanGen);
VectorToolBox.ReleaseVxs(ref v1);
// this is some debug you can enable to visualize the dest bounding box
//LineFloat(BoundingRect.left, BoundingRect.top, BoundingRect.right, BoundingRect.top, WHITE);
//LineFloat(BoundingRect.right, BoundingRect.top, BoundingRect.right, BoundingRect.bottom, WHITE);
//LineFloat(BoundingRect.right, BoundingRect.bottom, BoundingRect.left, BoundingRect.bottom, WHITE);
//LineFloat(BoundingRect.left, BoundingRect.bottom, BoundingRect.left, BoundingRect.top, WHITE);
}
else // TODO: this can be even faster if we do not use an intermediat buffer
{
Affine destRectTransform = BuildImageBoundsPath(source.Width, source.Height, destX, destY, imgBoundsPath);
// We invert it because it is the transform to make the image go to the same position as the polygon. LBB [2/24/2004]
Affine sourceRectTransform = destRectTransform.CreateInvert();
var interpolator = new SpanInterpolatorLinear(sourceRectTransform);
ImgSpanGen imgSpanGen = null;
switch (source.BitDepth)
{
case 32:
imgSpanGen = new ImgSpanGenRGBA_NN_StepXBy1(source, interpolator);
break;
//case 24:
// imgSpanGen = new ImgSpanGenRGB_NNStepXby1(source, interpolator);
// break;
case 8:
imgSpanGen = new ImgSpanGenGray_NNStepXby1(source, interpolator);
break;
default:
throw new NotImplementedException();
}
VectorToolBox.GetFreeVxs(out var v1);
destRectTransform.TransformToVxs(imgBoundsPath, v1);
Render(v1, imgSpanGen);
VectorToolBox.ReleaseVxs(ref v1);
unchecked { destImageChanged++; };
}
VectorToolBox.ReleaseVxs(ref imgBoundsPath);
}
public override void Render(IImageByte source,
double destX,
double destY,
double angleRadians,
double inScaleX,
double inScaleY)
{
Affine graphicsTransform = GetTransform();
// exit early if the dest and source bounds don't touch.
// TODO: <BUG> make this do rotation and scaling
RectangleInt sourceBounds = source.GetBounds();
RectangleInt destBounds = this.destImageByte.GetBounds();
sourceBounds.Offset((int)(destX + graphicsTransform.tx), (int)(destY + graphicsTransform.ty));
if (!RectangleInt.DoIntersect(sourceBounds, destBounds))
{
if (inScaleX != 1 || inScaleY != 1 || angleRadians != 0)
{
//throw new NotImplementedException();
}
//return;
}
double scaleX = inScaleX;
double scaleY = inScaleY;
if (!graphicsTransform.is_identity())
{
if (scaleX != 1 || scaleY != 1 || angleRadians != 0)
{
//throw new NotImplementedException();
}
graphicsTransform.transform(ref destX, ref destY);
}
#if false // this is an optimization that eliminates the drawing of images that have their alpha set to all 0 (happens with generated images like explosions).
MaxAlphaFrameProperty maxAlphaFrameProperty = MaxAlphaFrameProperty::GetMaxAlphaFrameProperty(source);
if ((maxAlphaFrameProperty.GetMaxAlpha() * color.A_Byte) / 256 <= ALPHA_CHANNEL_BITS_DIVISOR)
{
m_OutFinalBlitBounds.SetRect(0, 0, 0, 0);
}
#endif
bool isScaled = scaleX != 1 || scaleY != 1;
bool isRotated = true;
if (Math.Abs(angleRadians) < (0.1 * MathHelper.Tau / 360))
{
isRotated = false;
angleRadians = 0;
}
// bool IsMipped = false;
double sourceOriginOffsetX = source.OriginOffset.X;
double sourceOriginOffsetY = source.OriginOffset.Y;
bool canUseMipMaps = isScaled;
if (scaleX > 0.5 || scaleY > 0.5)
{
canUseMipMaps = false;
}
bool renderRequriesSourceSampling = isScaled || isRotated || destX != (int)destX || destY != (int)destY;
// this is the fast drawing path
if (renderRequriesSourceSampling)
{
#if false // if the scaling is small enough the results can be improved by using mip maps
if (CanUseMipMaps)
{
CMipMapFrameProperty *pMipMapFrameProperty = CMipMapFrameProperty::GetMipMapFrameProperty(source);
double OldScaleX = scaleX;
double OldScaleY = scaleY;
const CFrameInterface *pMippedFrame = pMipMapFrameProperty.GetMipMapFrame(ref scaleX, ref scaleY);
if (pMippedFrame != source)
{
IsMipped = true;
source = pMippedFrame;
sourceOriginOffsetX *= (OldScaleX / scaleX);
sourceOriginOffsetY *= (OldScaleY / scaleY);
}
HotspotOffsetX *= (inScaleX / scaleX);
HotspotOffsetY *= (inScaleY / scaleY);
}
#endif
switch (ImageRenderQuality)
{
case TransformQuality.Fastest:
{
DrawImageGetDestBounds(source, destX, destY, sourceOriginOffsetX, sourceOriginOffsetY, scaleX, scaleY, angleRadians, out Affine destRectTransform);
var sourceRectTransform = new Affine(destRectTransform);
// We invert it because it is the transform to make the image go to the same position as the polygon. LBB [2/24/2004]
sourceRectTransform.invert();
span_image_filter spanImageFilter;
var interpolator = new span_interpolator_linear(sourceRectTransform);
var sourceAccessor = new ImageBufferAccessorClip(source, ColorF.rgba_pre(0, 0, 0, 0).ToColor());
spanImageFilter = new span_image_filter_rgba_bilinear_clip(sourceAccessor, ColorF.rgba_pre(0, 0, 0, 0), interpolator);
DrawImage(spanImageFilter, destRectTransform);
}
break;
case TransformQuality.Best:
{
DrawImageGetDestBounds(source, destX, destY, sourceOriginOffsetX, sourceOriginOffsetY, scaleX, scaleY, angleRadians, out Affine destRectTransform);
var sourceRectTransform = new Affine(destRectTransform);
// We invert it because it is the transform to make the image go to the same position as the polygon. LBB [2/24/2004]
sourceRectTransform.invert();
var interpolator = new span_interpolator_linear(sourceRectTransform);
var sourceAccessor = new ImageBufferAccessorClip(source, ColorF.rgba_pre(0, 0, 0, 0).ToColor());
// spanImageFilter = new span_image_filter_rgba_bilinear_clip(sourceAccessor, RGBA_Floats.rgba_pre(0, 0, 0, 0), interpolator);
IImageFilterFunction filterFunction = null;
filterFunction = new image_filter_blackman(4);
var filter = new ImageFilterLookUpTable();
filter.calculate(filterFunction, true);
span_image_filter spanGenerator = new span_image_filter_rgba(sourceAccessor, interpolator, filter);
DrawImage(spanGenerator, destRectTransform);
}
break;
}
#if false // this is some debug you can enable to visualize the dest bounding box
LineFloat(BoundingRect.left, BoundingRect.top, BoundingRect.right, BoundingRect.top, WHITE);
LineFloat(BoundingRect.right, BoundingRect.top, BoundingRect.right, BoundingRect.bottom, WHITE);
LineFloat(BoundingRect.right, BoundingRect.bottom, BoundingRect.left, BoundingRect.bottom, WHITE);
LineFloat(BoundingRect.left, BoundingRect.bottom, BoundingRect.left, BoundingRect.top, WHITE);
#endif
}
else // TODO: this can be even faster if we do not use an intermediate buffer
{
DrawImageGetDestBounds(source, destX, destY, sourceOriginOffsetX, sourceOriginOffsetY, scaleX, scaleY, angleRadians, out Affine destRectTransform);
var sourceRectTransform = new Affine(destRectTransform);
// We invert it because it is the transform to make the image go to the same position as the polygon. LBB [2/24/2004]
sourceRectTransform.invert();
var interpolator = new span_interpolator_linear(sourceRectTransform);
var sourceAccessor = new ImageBufferAccessorClip(source, ColorF.rgba_pre(0, 0, 0, 0).ToColor());
span_image_filter spanImageFilter = null;
switch (source.BitDepth)
{
case 32:
spanImageFilter = new span_image_filter_rgba_nn_stepXby1(sourceAccessor, interpolator);
break;
case 24:
spanImageFilter = new span_image_filter_rgb_nn_stepXby1(sourceAccessor, interpolator);
break;
case 8:
spanImageFilter = new span_image_filter_gray_nn_stepXby1(sourceAccessor, interpolator);
break;
default:
throw new NotImplementedException();
}
// spanImageFilter = new span_image_filter_rgba_nn(sourceAccessor, interpolator);
DrawImage(spanImageFilter, destRectTransform);
DestImage.MarkImageChanged();
}
}
public void Render(IBitmapSrc source,
double destX, double destY,
double angleRadians,
double inScaleX, double inScaleY)
{
{ // exit early if the dest and source bounds don't touch.
// TODO: <BUG> make this do rotation and scalling
Q1Rect sourceBounds = source.GetBounds();
Q1Rect destBounds = _destBitmapBlender.GetBounds();
sourceBounds.Offset((int)destX, (int)destY);
if (!Q1Rect.DoIntersect(sourceBounds, destBounds))
{
if (inScaleX != 1 || inScaleY != 1 || angleRadians != 0)
{
throw new NotImplementedException();
}
return;
}
}
double scaleX = inScaleX;
double scaleY = inScaleY;
ICoordTransformer graphicsTransform = this.CurrentTransformMatrix;
if (!graphicsTransform.IsIdentity)
{
if (scaleX != 1 || scaleY != 1 || angleRadians != 0)
{
throw new NotImplementedException();
}
graphicsTransform.Transform(ref destX, ref destY);
}
#if false // this is an optomization that eliminates the drawing of images that have their alpha set to all 0 (happens with generated images like explosions).
MaxAlphaFrameProperty maxAlphaFrameProperty = MaxAlphaFrameProperty::GetMaxAlphaFrameProperty(source);
if ((maxAlphaFrameProperty.GetMaxAlpha() * color.A_Byte) / 256 <= ALPHA_CHANNEL_BITS_DIVISOR)
{
m_OutFinalBlitBounds.SetRect(0, 0, 0, 0);
}
#endif
bool isScale = (scaleX != 1 || scaleY != 1);
bool isRotated = true;
if (Math.Abs(angleRadians) < (0.1 * MathHelper.Tau / 360))
{
isRotated = false;
angleRadians = 0;
}
//bool IsMipped = false;
//double ox, oy;
//source.GetOriginOffset(out ox, out oy);
bool canUseMipMaps = isScale;
if (scaleX > 0.5 || scaleY > 0.5)
{
canUseMipMaps = false;
}
bool renderRequriesSourceSampling = isScale || isRotated || destX != (int)destX || destY != (int)destY;
using (VxsTemp.Borrow(out var v1, out var imgBoundsPath))
{
// this is the fast drawing path
if (renderRequriesSourceSampling)
{
// if the scalling is small enough the results can be improved by using mip maps
//if(CanUseMipMaps)
//{
// CMipMapFrameProperty* pMipMapFrameProperty = CMipMapFrameProperty::GetMipMapFrameProperty(source);
// double OldScaleX = scaleX;
// double OldScaleY = scaleY;
// const CFrameInterface* pMippedFrame = pMipMapFrameProperty.GetMipMapFrame(ref scaleX, ref scaleY);
// if(pMippedFrame != source)
// {
// IsMipped = true;
// source = pMippedFrame;
// sourceOriginOffsetX *= (OldScaleX / scaleX);
// sourceOriginOffsetY *= (OldScaleY / scaleY);
// }
// HotspotOffsetX *= (inScaleX / scaleX);
// HotspotOffsetY *= (inScaleY / scaleY);
//}
//Affine destRectTransform = BuildImageBoundsPath(source.Width, source.Height,
// destX, destY, ox, oy, scaleX, scaleY, angleRadians, imgBoundsPath);
//1.
BuildOrgImgRectVxs(source.Width, source.Height, imgBoundsPath);
//2.
AffineMat destRectTransform = AffineMat.Iden();
destRectTransform.Translate(-_ox, -_oy);
destRectTransform.Scale(scaleX, scaleY);
destRectTransform.Rotate(angleRadians);
//TODO: review reusable span generator an interpolator ***
// We invert it because it is the transform to make the image go to the same position as the polygon. LBB [2/24/2004]
_reuseableAffine.SetElements(destRectTransform.CreateInvert());
_spanInterpolator.Transformer = _reuseableAffine;
_currentImgSpanGen.BackgroundColor = Drawing.Color.Black;
_currentImgSpanGen.SetInterpolator(_spanInterpolator);
_currentImgSpanGen.SetSrcBitmap(source);
destRectTransform.TransformToVxs(imgBoundsPath, v1); //not inverted version
Render(v1, _currentImgSpanGen);
_currentImgSpanGen.ReleaseSrcBitmap();
// this is some debug you can enable to visualize the dest bounding box
//LineFloat(BoundingRect.left, BoundingRect.top, BoundingRect.right, BoundingRect.top, WHITE);
//LineFloat(BoundingRect.right, BoundingRect.top, BoundingRect.right, BoundingRect.bottom, WHITE);
//LineFloat(BoundingRect.right, BoundingRect.bottom, BoundingRect.left, BoundingRect.bottom, WHITE);
//LineFloat(BoundingRect.left, BoundingRect.bottom, BoundingRect.left, BoundingRect.top, WHITE);
}
else // TODO: this can be even faster if we do not use an intermediat buffer
{
//Affine destRectTransform = BuildImageBoundsPath(source.Width, source.Height, destX, destY, imgBoundsPath);
BuildOrgImgRectVxs(source.Width, source.Height, imgBoundsPath);
//
var destRectTransform = new AffineMat();
destRectTransform.Translate(destX, destY);
//TODO: review reusable span generator an interpolator ***
// We invert it because it is the transform to make the image go to the same position as the polygon. LBB [2/24/2004]
_reuseableAffine.SetElements(destRectTransform.CreateInvert());
_spanInterpolator.Transformer = _reuseableAffine;
ImgSpanGen imgSpanGen = null;
switch (source.BitDepth)
{
case 32:
if (_imgSpanGenCustom != null)
{
//use custom span gen
_imgSpanGenCustom.SetInterpolator(_spanInterpolator);
_imgSpanGenCustom.SetSrcBitmap(source);
imgSpanGen = _imgSpanGenCustom;
}
else
{
_imgSpanGenNNStepXBy1.SetInterpolator(_spanInterpolator);
_imgSpanGenNNStepXBy1.SetSrcBitmap(source);
imgSpanGen = _imgSpanGenNNStepXBy1;
}
break;
//case 24:
// imgSpanGen = new ImgSpanGenRGB_NNStepXby1(source, interpolator);
// break;
//case 8:
// imgSpanGen = new ImgSpanGenGray_NNStepXby1(source, interpolator);
// break;
default:
throw new NotImplementedException();
}
TransformToVxs(destRectTransform, imgBoundsPath, v1);
Render(v1, imgSpanGen);
unchecked { _destImageChanged++; };
}
}
}
