// this test checks that all native filters have a managed peer, i.e. against missing filters
public void CheckNativeFilters()
{
Errors = 0;
List <string> filters = new List <string> ();
int n = 0;
string qname = CIFilterType.AssemblyQualifiedName;
// that will give us only the list of filters supported by the executing version of iOS
foreach (var filter_name in CIFilter.FilterNamesInCategories(null))
{
if (Skip(filter_name))
{
continue;
}
string type_name = qname.Replace("CIFilter", filter_name);
if (Type.GetType(type_name, false, true) == null)
{
filters.Add(filter_name);
if (BindingOutput != null)
{
GenerateBinding(CIFilter.FromName(filter_name), BindingOutput);
}
}
n++;
}
Assert.That(filters.Count, Is.EqualTo(0), "{0} native filters missing: {1}", filters.Count, String.Join(", ", filters));
}
public override void DidOrderIn(PresentationViewController presentationViewController)
{
var banana = Utils.SCAddChildNode(ContentNode, "banana", "Scenes.scnassets/banana/banana", 5);
banana.Rotation = new SCNVector4(1, 0, 0, -(float)(Math.PI / 2));
banana.RunAction(SCNAction.RepeatActionForever(SCNAction.RotateBy(0, NMath.PI * 2, 0, 1.5f)));
banana.Position = new SCNVector3(2.5f, 5, 10);
var gaussianBlurFilter = new CIGaussianBlur()
{
Radius = 10
};
gaussianBlurFilter.SetDefaults();
banana.Filters = new CIFilter[] { gaussianBlurFilter };
banana = (SCNNode)banana.Copy();
ContentNode.AddChildNode(banana);
banana.Position = new SCNVector3(6, 5, 10);
var pixellateFilter = new CIPixellate();
pixellateFilter.SetDefaults();
banana.Filters = new CIFilter[] { pixellateFilter };
banana = (SCNNode)banana.Copy();
ContentNode.AddChildNode(banana);
banana.Position = new SCNVector3(9.5f, 5, 10);
var filter = CIFilter.FromName("CIEdgeWork");
filter.SetDefaults();
banana.Filters = new CIFilter[] { filter };
}
private CIFilter[] CompositionFilters()
{
var blurFilter = CIFilter.FromName("CIGaussianBlur");
blurFilter.SetDefaults();
blurFilter.SetValueForKey((NSNumber)2, (NSString)"inputRadius");
return(new CIFilter[] { blurFilter });
}
public CIImage OutputImage()
{
var inputImage = ValueForKey(new NSString("inputImage"));
if (inputImage == null)
{
return(null);
}
// Monochrome
var monochromeFilter = CIFilter.FromName("CIColorMatrix");
monochromeFilter.SetDefaults();
monochromeFilter.SetValueForKey(CIVector.Create(0, 0, 0), new NSString("inputRVector"));
monochromeFilter.SetValueForKey(CIVector.Create(0, 0, 0.4f), new NSString("inputGVector"));
monochromeFilter.SetValueForKey(CIVector.Create(0, 0, 1), new NSString("inputBVector"));
monochromeFilter.SetValueForKey(CIVector.Create(0, 0, 1), new NSString("inputAVector"));
monochromeFilter.SetValueForKey(inputImage, new NSString("inputImage"));
var glowImage = (CIImage)monochromeFilter.ValueForKey(new NSString("outputImage"));
// Scale
var centerX = CenterX;
var centerY = CenterY;
if (centerX > 0)
{
var transform = new NSAffineTransform();
transform.Translate(centerX, centerY);
transform.Scale(1.2f);
transform.Translate(-centerX, -centerY);
var affineTransformFilter = CIFilter.FromName("CIAffineTransform");
affineTransformFilter.SetDefaults();
affineTransformFilter.SetValueForKey(transform, new NSString("inputTransform"));
affineTransformFilter.SetValueForKey(glowImage, new NSString("inputImage"));
glowImage = (CIImage)affineTransformFilter.ValueForKey(new NSString("outputImage"));
}
// Blur
var gaussianBlurFilter = CIFilter.FromName("CIGaussianBlur");
gaussianBlurFilter.SetDefaults();
gaussianBlurFilter.SetValueForKey(glowImage, new NSString("inputImage"));
gaussianBlurFilter.SetValueForKey(InputRadius != null ? InputRadius : new NSNumber(10.0f), new NSString("inputRadius"));
glowImage = (CIImage)gaussianBlurFilter.ValueForKey(new NSString("outputImage"));
// Blend
var blendFilter = CIFilter.FromName("CISourceOverCompositing");
blendFilter.SetDefaults();
blendFilter.SetValueForKey(glowImage, new NSString("inputBackgroundImage"));
blendFilter.SetValueForKey(blendFilter, new NSString("inputImage"));
glowImage = (CIImage)blendFilter.ValueForKey(new NSString("outputImage"));
return(glowImage);
}
private void Pointalize()
{
CIVector center = CIVector.Create(Bounds.GetMidX(), Bounds.GetMidY());
CIFilter pointalize = CIFilter.FromName("CIPointillize");
pointalize.SetValueForKey(NSNumber.FromFloat(1), CIFilterInputKey.Radius);
pointalize.SetValueForKey(center, CIFilterInputKey.Center);
controls.ContentFilters = new CIFilter[] { pointalize };
}
private void UpdateFilter()
{
ciFilter = CIFilter.FromName(selectedFilterName);
var inputImage = CIImage.FromCGImage(this.inputImage.CGImage);
CIImageOrientation orientation = Convert(this.inputImage.Orientation);
inputImage = inputImage.CreateWithOrientation(orientation);
ciFilter.Image = inputImage;
}
CIImage CreateQRForString(NSString qrString, QRCodeCorrectionLevel level)
{
NSData strData = qrString.Encode(NSStringEncoding.UTF8);
// 创建filter
CIFilter qrFilter = CIFilter.FromName("CIQRCodeGenerator");
// 设置内容和纠错级别
qrFilter.SetValueForKey(strData, new NSString("inputMessage"));
qrFilter.SetValueForKey(new NSString(level.ToString()), new NSString("inputCorrectionLevel"));
// 返回CIImage
return(qrFilter.OutputImage);
}
protected override void OnAttached()
{
if (Container is NSView)
{
var control = (Container as NSView);
control.WantsLayer = true;
control.LayerUsesCoreImageFilters = true;
filter = CIFilter.FromName("CIGaussianBlur");
filter.SetDefaults();
}
}
void UpdateFilter()
{
TryDisposeFilterInput();
TryDisposeFilter();
ciFilter = CIFilter.FromName(selectedFilterName);
CIImageOrientation orientation = Convert(inputImage.Orientation);
using (CGImage cgImage = inputImage.CGImage) {
using (CIImage ciInputImage = CIImage.FromCGImage(cgImage))
ciFilter.Image = ciInputImage.CreateWithOrientation(orientation);
}
}
public static NSImage Tint(this NSImage image, NSColor tint)
{
CIFilter colorGenerator = CIFilter.FromName("CIConstantColorGenerator");
CIColor color = CIColor.FromCGColor(tint.ToCG());
colorGenerator.SetValueForKey(color, CIFilterInputKey.Color);
CIFilter colorFilter = CIFilter.FromName("CIColorControls");
colorFilter.SetValueForKey(colorGenerator.ValueForKey(CIFilterOutputKey.Image), CIFilterInputKey.Image);
colorFilter.SetValueForKey(NSNumber.FromFloat(3f), CIFilterInputKey.Saturation);
colorFilter.SetValueForKey(NSNumber.FromFloat(0.35f), CIFilterInputKey.Brightness);
colorFilter.SetValueForKey(NSNumber.FromFloat(1f), CIFilterInputKey.Contrast);
CIFilter monochromeFilter = CIFilter.FromName("CIColorMonochrome");
CIImage baseImage = CIImage.FromCGImage(image.CGImage);
monochromeFilter.SetValueForKey(baseImage, CIFilterInputKey.Image);
monochromeFilter.SetValueForKey(CIColor.FromRgb(0.75f, 0.75f, 0.75f), CIFilterInputKey.Color);
monochromeFilter.SetValueForKey(NSNumber.FromFloat(1f), CIFilterInputKey.Intensity);
CIFilter compositingFilter = CIFilter.FromName("CIMultiplyCompositing");
compositingFilter.SetValueForKey(colorFilter.ValueForKey(CIFilterOutputKey.Image), CIFilterInputKey.Image);
compositingFilter.SetValueForKey(monochromeFilter.ValueForKey(CIFilterOutputKey.Image), CIFilterInputKey.BackgroundImage);
CIImage outputImage = (CIImage)compositingFilter.ValueForKey(CIFilterOutputKey.Image);
var extent = outputImage.Extent;
var newsize = sd.Size.Truncate(extent.Size);
var tintedImage = new NSImage(newsize);
var newrep = new NSBitmapImageRep(IntPtr.Zero, newsize.Width, newsize.Height, 8, 4, true, false, NSColorSpace.DeviceRGB, 4 * newsize.Width, 32);
tintedImage.AddRepresentation(newrep);
var graphics = NSGraphicsContext.FromBitmap(newrep);
NSGraphicsContext.GlobalSaveGraphicsState();
NSGraphicsContext.CurrentContext = graphics;
var ciContext = CIContext.FromContext(graphics.GraphicsPort, new CIContextOptions {
UseSoftwareRenderer = true
});
ciContext.DrawImage(outputImage, extent, extent);
NSGraphicsContext.GlobalRestoreGraphicsState();
newrep.Size = image.Size;
return(tintedImage);
}
public static void Colourize(NSView control, Color color, Action drawAction)
{
var size = control.Frame.Size;
var image = new NSImage(size);
image.LockFocusFlipped(control.IsFlipped);
drawAction();
image.UnlockFocus();
var ciImage = CIImage.FromData(image.AsTiff());
if (control.IsFlipped)
{
var realSize = control.ConvertSizeToBase(size);
var affineTransform = new NSAffineTransform();
affineTransform.Translate(0, realSize.Height);
affineTransform.Scale(1, -1);
var filter1 = CIFilter.FromName("CIAffineTransform");
filter1.SetValueForKey(ciImage, CIInputImage);
filter1.SetValueForKey(affineTransform, CIInputTransform);
ciImage = filter1.ValueForKey(CIOutputImage) as CIImage;
}
var filter2 = CIFilter.FromName("CIColorControls");
filter2.SetDefaults();
filter2.SetValueForKey(ciImage, CIInputImage);
filter2.SetValueForKey(new NSNumber(0.0f), CIInputSaturation);
ciImage = filter2.ValueForKey(CIOutputImage) as CIImage;
var filter3 = CIFilter.FromName("CIColorMatrix");
filter3.SetDefaults();
filter3.SetValueForKey(ciImage, CIInputImage);
filter3.SetValueForKey(new CIVector(0, color.R, 0), CIInputRVector);
filter3.SetValueForKey(new CIVector(color.G, 0, 0), CIInputGVector);
filter3.SetValueForKey(new CIVector(0, 0, color.B), CIInputBVector);
ciImage = filter3.ValueForKey(CIOutputImage) as CIImage;
image = new NSImage(size);
var rep = NSCIImageRep.FromCIImage(ciImage);
image.AddRepresentation(rep);
image.Draw(SD.PointF.Empty, new SD.RectangleF(SD.PointF.Empty, size), NSCompositingOperation.SourceOver, 1);
/* Use this when implemented in maccore:
* ciImage.Draw (SD.PointF.Empty, new SD.RectangleF (SD.PointF.Empty, size), NSCompositingOperation.SourceOver, 1);
*/
}
UIImage machineReadableCodeFromMessage(string message)
{
var mrcFilter = CIFilter.FromName("CIQRCodeGenerator");
NSData messageData = NSData.FromString(new NSString(message), NSStringEncoding.UTF8);
mrcFilter.SetValueForKey(messageData, (NSString)"inputMessage");
var barcodeCIImage = (CIImage)mrcFilter.ValueForKey((NSString)"outputImage");
CGRect extent = barcodeCIImage.Extent;
CGImage barcodeCGImage = CIContext.CreateCGImage(barcodeCIImage, extent);
UIImage image = new UIImage(barcodeCGImage);
return(image);
}
CIImage WillDisplayImage(QTCaptureView view, CIImage image)
{
if (description == null)
{
return(image);
}
var selectedFilter = (NSString)description [filterNameKey];
var filter = CIFilter.FromName(selectedFilter);
filter.SetDefaults();
filter.Image = image;
return(filter.OutputImage);
}
/// <summary>
/// Tint the icon with the specified colour
/// </summary>
/// <param name="colour">Colour to tint icon with</param>
public void TintIcon(CIColor colour)
{
// Use CoreImage to tint the icon
var statusImage = CIImage.FromUrl(NSUrl.FromFilename(NSBundle.MainBundle.PathForResource(
Path.GetFileNameWithoutExtension(HighlightImagePath), Path.GetExtension(HighlightImagePath))));
var tintImage = CIImage.ImageWithColor(colour);
var filter = CIFilter.FromName("CIMultiplyCompositing");
filter.SetValueForKey(tintImage, (NSString)"inputImage");
filter.SetValueForKey(statusImage, (NSString)"inputBackgroundImage");
var processedImage = (CIImage)filter.ValueForKey((NSString)"outputImage");
var outputImage = processedImage.ToNSImage();
_statusItemView.Image = outputImage;
}
void ApplyFilter()
{
CIVector center = CIVector.Create(Bounds.GetMidX(), Bounds.GetMidY());
CIFilter torus = CIFilter.FromName("CITorusLensDistortion");
var keys = new NSString[] { CIFilterInputKey.Center,
CIFilterInputKey.Radius,
CIFilterInputKey.Width,
CIFilterInputKey.Refraction };
var values = new NSObject[] { center,
NSNumber.FromFloat(150),
NSNumber.FromFloat(2),
NSNumber.FromFloat(1.7f) };
torus.SetValuesForKeysWithDictionary(NSDictionary.FromObjectsAndKeys(values, keys));
controls.BackgroundFilters = new CIFilter[] { torus };
AddAnimationToTorusFilter();
}
public void DrawImage(Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttrs)
{
if (image == null)
{
throw new ArgumentNullException("image");
}
var srcRect1 = new RectangleF(srcX, srcY, srcWidth, srcHeight);
// If the source units are not the same we need to convert them
// The reason we check for Pixel here is that our graphics already has the Pixel's baked into the model view transform
if (srcUnit != graphicsUnit && srcUnit != GraphicsUnit.Pixel)
{
ConversionHelpers.GraphicsUnitConversion(srcUnit, graphicsUnit, image.HorizontalResolution, image.VerticalResolution, ref srcRect1);
}
if (image.NativeCGImage == null)
{
DrawImage(image, destRect);
return;
}
// Obtain the subImage
var subImage = image.NativeCGImage.WithImageInRect(srcRect1.ToCGRect());
// If we do not have anything to draw then we exit here
if (subImage.Width == 0 || subImage.Height == 0)
{
return;
}
// var transform = image.imageTransform;
//// // Reset our height on the transform to account for subImage
// transform.y0 = subImage.Height;
////
//// // Make sure we scale the image in case the source rectangle
//// // overruns our subimage bouncs width and/or height
// float scaleX = subImage.Width/srcRect1.Width;
// float scaleY = subImage.Height/srcRect1.Height;
// transform.Scale (scaleX, scaleY);
bool attributesSet = imageAttrs != null && (imageAttrs.isColorMatrixSet || imageAttrs.isGammaSet);
if (attributesSet)
{
InitializeImagingContext();
CIImage result = subImage;
if (imageAttrs.isColorMatrixSet)
{
var ciFilter = CIFilter.FromName("CIColorMatrix");
ciFilter.SetDefaults();
ciFilter.SetValueForKey(result, new NSString("inputImage"));
var inputRVector = new CIVector(imageAttrs.colorMatrix.Matrix00, imageAttrs.colorMatrix.Matrix01, imageAttrs.colorMatrix.Matrix02, imageAttrs.colorMatrix.Matrix03);
var inputGVector = new CIVector(imageAttrs.colorMatrix.Matrix10, imageAttrs.colorMatrix.Matrix11, imageAttrs.colorMatrix.Matrix12, imageAttrs.colorMatrix.Matrix13);
var inputBVector = new CIVector(imageAttrs.colorMatrix.Matrix20, imageAttrs.colorMatrix.Matrix21, imageAttrs.colorMatrix.Matrix22, imageAttrs.colorMatrix.Matrix23);
var inputAVector = new CIVector(imageAttrs.colorMatrix.Matrix30, imageAttrs.colorMatrix.Matrix31, imageAttrs.colorMatrix.Matrix32, imageAttrs.colorMatrix.Matrix33);
var inputBiasVector = new CIVector(imageAttrs.colorMatrix.Matrix40, imageAttrs.colorMatrix.Matrix41, imageAttrs.colorMatrix.Matrix42, imageAttrs.colorMatrix.Matrix43);
ciFilter.SetValueForKey(inputRVector, new NSString("inputRVector"));
ciFilter.SetValueForKey(inputGVector, new NSString("inputGVector"));
ciFilter.SetValueForKey(inputBVector, new NSString("inputBVector"));
ciFilter.SetValueForKey(inputAVector, new NSString("inputAVector"));
ciFilter.SetValueForKey(inputBiasVector, new NSString("inputBiasVector"));
result = (CIImage)ciFilter.ValueForKey(new NSString("outputImage"));
}
if (imageAttrs.isGammaSet)
{
var ciFilter = CIFilter.FromName("CIGammaAdjust");
ciFilter.SetDefaults();
ciFilter.SetValueForKey(result, new NSString("inputImage"));
var inputPower = NSNumber.FromFloat(imageAttrs.gamma);
ciFilter.SetValueForKey(inputPower, new NSString("inputPower"));
result = (CIImage)ciFilter.ValueForKey(new NSString("outputImage"));
}
subImage = ciContext.CreateCGImage(result, result.Extent);
}
transform = image.imageTransform;
transform.y0 = subImage.Height;
float scaleX1 = subImage.Width / srcRect1.Width;
float scaleY1 = subImage.Height / srcRect1.Height;
transform.Scale(scaleX1, scaleY1);
// Now draw our image
DrawImage(destRect, subImage, transform);
}
public override void PresentStep(int switchIndex, PresentationViewController presentationViewController)
{
switch (switchIndex)
{
case 0:
// Set the slide's title and subtitle and add some text
TextManager.SetTitle("Core Image");
TextManager.SetSubtitle("CI Filters");
TextManager.AddBulletAtLevel("Screen-space effects", 0);
TextManager.AddBulletAtLevel("Applies to a node hierarchy", 0);
TextManager.AddBulletAtLevel("Filter parameters are animatable", 0);
TextManager.AddCode("#aNode.#Filters# = new CIFilter[] { filter1, filter2 };#");
break;
case 1:
SCNTransaction.Begin();
SCNTransaction.AnimationDuration = 1.0f;
// Dim the text and move back a little
TextManager.TextNode.Opacity = 0.0f;
presentationViewController.CameraHandle.Position = presentationViewController.CameraNode.ConvertPositionToNode(new SCNVector3(0, 0, 5.0f), presentationViewController.CameraHandle.ParentNode);
SCNTransaction.Commit();
// Reveal the grid
GroupNode.Opacity = 1;
break;
case 2:
SCNTransaction.Begin();
SCNTransaction.AnimationDuration = 1;
// Highlight an item
HighlightContact(13, presentationViewController);
SCNTransaction.Commit();
break;
case 3:
var index = 13;
var subStep = 0;
// Successively select items
for (var i = 0; i < 5; ++i)
{
var popTime = new DispatchTime(DispatchTime.Now, (long)(i * 0.2 * Utils.NSEC_PER_SEC));
DispatchQueue.MainQueue.DispatchAfter(popTime, () => {
SCNTransaction.Begin();
SCNTransaction.AnimationDuration = 0.2f;
UnhighlightContact(index);
if (subStep++ == 3)
{
index += ColumnCount;
}
else
{
index++;
}
HighlightContact(index, presentationViewController);
SCNTransaction.Commit();
});
}
break;
case 4:
// BLUR+DESATURATE in the background, GLOW in the foreground
// Here we will change the node hierarchy in order to group all the nodes in the background under a single node.
// This way we can use a single Core Image filter and apply it on the whole grid, and have another CI filter for the node in the foreground.
var selectionParent = HeroNode.ParentNode;
SCNTransaction.Begin();
SCNTransaction.AnimationDuration = 0;
// Stop the animations of the selected node
HeroNode.Transform = HeroNode.PresentationNode.Transform; // set the current rotation to the current presentation value
HeroNode.RemoveAllAnimations();
// Re-parent the node by preserving its world tranform
var wantedWorldTransform = selectionParent.WorldTransform;
GroupNode.ParentNode.AddChildNode(selectionParent);
selectionParent.Transform = selectionParent.ParentNode.ConvertTransformFromNode(wantedWorldTransform, null);
SCNTransaction.Commit();
// Add CIFilters
SCNTransaction.Begin();
SCNTransaction.AnimationDuration = 1;
// A negative 'centerX' value means no scaling.
//TODO HeroNode.Filters [0].SetValueForKey (new NSNumber (-1), new NSString ("centerX"));
// Move the selection to the foreground
selectionParent.Rotation = new SCNVector4(0, 1, 0, 0);
HeroNode.Transform = ContentNode.ConvertTransformToNode(SCNMatrix4.CreateTranslation(0, Altitude, 29), selectionParent);
HeroNode.Scale = new SCNVector3(1, 1, 1);
HeroNode.Rotation = new SCNVector4(1, 0, 0, -(float)(Math.PI / 4) * 0.25f);
// Upon completion, rotate the selection forever
SCNTransaction.SetCompletionBlock(() => {
var animation = CABasicAnimation.FromKeyPath("rotation");
animation.Duration = 4.0f;
animation.From = NSValue.FromVector(new SCNVector4(0, 1, 0, 0));
animation.To = NSValue.FromVector(new SCNVector4(0, 1, 0, NMath.PI * 2));
animation.TimingFunction = CAMediaTimingFunction.FromName(CAMediaTimingFunction.EaseInEaseOut);
animation.RepeatCount = float.MaxValue;
HeroNode.ChildNodes [0].AddAnimation(animation, new NSString("heroNodeAnimation"));
});
// Add the filters
var blurFilter = CIFilter.FromName("CIGaussianBlur");
blurFilter.SetDefaults();
blurFilter.Name = "blur";
blurFilter.SetValueForKey(new NSNumber(0), CIFilterInputKey.Radius);
var desaturateFilter = CIFilter.FromName("CIColorControls");
desaturateFilter.SetDefaults();
desaturateFilter.Name = "desaturate";
GroupNode.Filters = new CIFilter[] { blurFilter, desaturateFilter };
SCNTransaction.Commit();
// Increate the blur radius and desaturate progressively
SCNTransaction.Begin();
SCNTransaction.AnimationDuration = 2;
GroupNode.SetValueForKey(new NSNumber(10), new NSString("filters.blur.inputRadius"));
GroupNode.SetValueForKey(new NSNumber(0.1), new NSString("filters.desaturate.inputSaturation"));
SCNTransaction.Commit();
break;
}
}
private static CIFilter CreateFilter()
{
//const unsigned int size = 64;
const uint size = 64;
const float minHueAngle = 0f; // change these
const float maxHueAngle = 1f; // two
//float *cubeData = (float *)malloc (size * size * size * sizeof (float) * 4);
var cubeData = new float[size * size * size * 4];
//float rgb[3], hsv[3], *c = cubeData;
float[] rgb = new float[3], hsv = new float[3];
// Populate cube with a simple gradient going from 0 to 1
// for (int z = 0; z < size; z++){
// rgb[2] = ((double)z)/(size-1); // Blue value
// for (int y = 0; y < size; y++){
// rgb[1] = ((double)y)/(size-1); // Green value
// for (int x = 0; x < size; x ++){
// rgb[0] = ((double)x)/(size-1); // Red value
// // Convert RGB to HSV
// // You can find publicly available rgbToHSV functions on the Internet
// rgbToHSV(rgb, hsv);
// // Use the hue value to determine which to make transparent
// // The minimum and maximum hue angle depends on
// // the color you want to remove
// float alpha = (hsv[0] > minHueAngle && hsv[0] < maxHueAngle) ? 0.0f: 1.0f;
// // Calculate premultiplied alpha values for the cube
// c[0] = rgb[0] * alpha;
// c[1] = rgb[1] * alpha;
// c[2] = rgb[2] * alpha;
// c[3] = alpha;
// c += 4; // advance our pointer into memory for the next color value
// }
// }
// }
NSData data;
unsafe
{
fixed(float *ptr = cubeData)
{
float *c = ptr;
for (var z = 0; z < size; z++)
{
rgb [2] = z / (size - 1); // Blue value
for (int y = 0; y < size; y++)
{
rgb [1] = y / (size - 1); // Green value
for (int x = 0; x < size; x++)
{
rgb [0] = x / (size - 1); // Red value
// Convert RGB to HSV
// You can find publicly available rgbToHSV functions on the Internet
ColorSpace.RGBtoHSV(rgb [0], rgb [1], rgb [2], out hsv [0], out hsv [1], out hsv [2]);
// Use the hue value to determine which to make transparent
// The minimum and maximum hue angle depends on
// the color you want to remove
float alpha = (hsv [0] > minHueAngle && hsv [0] < maxHueAngle) ? 0.0f : 1.0f;
// Calculate premultiplied alpha values for the cube
c[0] = rgb [0] * alpha;
c[1] = rgb [1] * alpha;
c[2] = rgb [2] * alpha;
c[3] = alpha;
c += 4;
}
}
}
// Create memory with the cube data
// NSData *data = [NSData dataWithBytesNoCopy:cubeData
// length:cubeDataSize
// freeWhenDone:YES];
// IntPtr pointer = (IntPtr)ptr;
// data = NSData.FromBytesNoCopy (pointer, (uint)cubeData.Length, true);
}
}
// Create memory with the cube data
// NSData *data = [NSData dataWithBytesNoCopy:cubeData
// length:cubeDataSize
// freeWhenDone:YES];
var bytes = new List <byte> ();
Array.ForEach(cubeData, a => bytes.AddRange(BitConverter.GetBytes(a)));
data = NSData.FromArray(bytes.ToArray());
// CIColorCube *colorCube = [CIFilter filterWithName:@" CIColorCube"];
var colorCube = CIFilter.FromName("CIColorCube");
// [colorCube setValue:@(size) forKey:@" inputCubeDimension"];
colorCube.SetValueForKey(NSObject.FromObject(size), new NSString("inputCubeDimension"));
// Set data for cube
// [colorCube setValue:data forKey:@" inputCubeData"];
colorCube.SetValueForKey(data, new NSString("inputCubeData"));
return(colorCube);
}
// this test checks that all managed filters have a native peer, i.e. against extra filters
public void CheckManagedFilters()
{
Errors = 0;
ContinueOnFailure = true;
List <string> filters = new List <string> (CIFilter.FilterNamesInCategories(null));
var superFilters = new List <string> ();
var nspace = CIFilterType.Namespace;
var types = CIFilterType.Assembly.GetTypes();
foreach (Type t in types)
{
if (t.Namespace != nspace)
{
continue;
}
if (t.IsAbstract || !CIFilterType.IsAssignableFrom(t))
{
continue;
}
// we need to skip the filters that are not supported by the executing version of iOS
if (Skip(t))
{
continue;
}
var ctor = t.GetConstructor(Type.EmptyTypes);
if ((ctor == null) || ctor.IsAbstract)
{
continue;
}
NSObject obj = ctor.Invoke(null) as NSObject;
#if false
// check base type - we might have our own base type or different names, so it's debug only (not failure)
var super = new Class(obj.Class.SuperClass).Name;
var bt = t.BaseType.Name;
if ((super != bt) && (bt == "CIFilter")) // check if we should (like Apple) use a non-default base type for filters
{
Console.WriteLine("[WARN] {0}.SuperClass == {1} (native) and {2} managed", t.Name, super, bt);
if (!superFilters.Contains(super))
{
superFilters.Add(super);
Console.WriteLine("[GENERATED] {0}", super);
GenerateBinding(CIFilter.FromName(super), BindingOutput);
}
}
#endif
int result = filters.RemoveAll(s => StringComparer.OrdinalIgnoreCase.Compare(t.Name, s) == 0);
if ((result == 0) && !Skip(t))
{
ReportError($"Managed {t.Name} was not part of the native filter list");
}
}
// in case it's a buggy filter we need to try to remove it from the list too
for (int i = filters.Count - 1; i >= 0; i--)
{
if (Skip(filters [i]))
{
filters.RemoveAt(i);
}
}
Assert.That(filters.Count, Is.EqualTo(0), "Managed filters not found for {0}", String.Join(", ", filters));
}
/* [Export("initWithCoder:")]
* public QTRDocument (NSCoder coder) : base(coder)
* {
* }*/
public override void WindowControllerDidLoadNib(NSWindowController windowController)
{
NSError error;
base.WindowControllerDidLoadNib(windowController);
// Create session
session = new QTCaptureSession();
// Attach preview to session
captureView.CaptureSession = session;
captureView.WillDisplayImage = (view, image) => {
if (videoPreviewFilterDescription == null)
{
return(image);
}
var selectedFilter = (NSString)videoPreviewFilterDescription [filterNameKey];
var filter = CIFilter.FromName(selectedFilter);
filter.SetDefaults();
filter.SetValueForKey(image, CIFilterInputKey.Image);
return((CIImage)filter.ValueForKey(CIFilterOutputKey.Image));
};
// Attach outputs to session
movieFileOutput = new QTCaptureMovieFileOutput();
movieFileOutput.WillStartRecording += delegate {
Console.WriteLine("Will start recording");
};
movieFileOutput.DidStartRecording += delegate {
Console.WriteLine("Started Recording");
};
movieFileOutput.ShouldChangeOutputFile = (output, url, connections, reason) => {
// Should change the file on error
Console.WriteLine(reason.LocalizedDescription);
return(false);
};
movieFileOutput.MustChangeOutputFile += delegate(object sender, QTCaptureFileErrorEventArgs e) {
Console.WriteLine("Must change file due to error");
};
// These ones we care about, some notifications
movieFileOutput.WillFinishRecording += delegate(object sender, QTCaptureFileErrorEventArgs e) {
Console.WriteLine("Will finish recording");
InvokeOnMainThread(delegate {
WillChangeValue("Recording");
});
};
movieFileOutput.DidFinishRecording += delegate(object sender, QTCaptureFileErrorEventArgs e) {
Console.WriteLine("Recorded {0} bytes duration {1}", movieFileOutput.RecordedFileSize, movieFileOutput.RecordedDuration);
DidChangeValue("Recording");
if (e.Reason != null)
{
NSAlert.WithError(e.Reason).BeginSheet(Window, () => {});
return;
}
var save = NSSavePanel.SavePanel;
save.AllowedFileTypes = new string[] { "mov" };
save.CanSelectHiddenExtension = true;
save.Begin(code => {
NSError err2;
if (code == (int)NSPanelButtonType.Ok)
{
NSFileManager.DefaultManager.Move(e.OutputFileURL, save.Url, out err2);
}
else
{
NSFileManager.DefaultManager.Remove(e.OutputFileURL.Path, out err2);
}
});
};
session.AddOutput(movieFileOutput, out error);
audioPreviewOutput = new QTCaptureAudioPreviewOutput();
session.AddOutput(audioPreviewOutput, out error);
if (VideoDevices.Length > 0)
{
SelectedVideoDevice = VideoDevices [0];
}
if (AudioDevices.Length > 0)
{
SelectedAudioDevice = AudioDevices [0];
}
session.StartRunning();
// events: devices added/removed
AddObserver(QTCaptureDevice.WasConnectedNotification, DevicesDidChange);
AddObserver(QTCaptureDevice.WasDisconnectedNotification, DevicesDidChange);
// events: connection format changes
AddObserver(QTCaptureConnection.FormatDescriptionDidChangeNotification, FormatDidChange);
AddObserver(QTCaptureConnection.FormatDescriptionWillChangeNotification, FormatWillChange);
AddObserver(QTCaptureDevice.AttributeDidChangeNotification, AttributeDidChange);
AddObserver(QTCaptureDevice.AttributeWillChangeNotification, AttributeWillChange);
}
