Ruční ovládací prvky Kamera v Xamarin.iOS

Článek
06/01/2023

Ovládací prvky Ruční Kamera poskytované v iOSu AVFoundation Framework 8 umožňují mobilní aplikaci převzít plnou kontrolu nad fotoaparátem zařízení s iOSem. Tuto jemně odstupňovanou úroveň ovládání lze použít k vytváření profesionálních aplikací fotoaparátů a poskytování uměleckých skladeb úpravou parametrů kamery při pořizování stále obrazu nebo videa.

Tyto ovládací prvky mohou být užitečné také při vývoji vědeckých nebo průmyslových aplikací, kde jsou výsledky méně zaměřené na správnost nebo krásu obrázku a jsou zaměřeny spíše na zvýraznění některé funkce nebo prvku pořízeného obrázku.

Zachytávání objektů AVFoundation

Bez ohledu na to, jestli pořizujete video nebo stále obrázky pomocí fotoaparátu na zařízení s iOSem, je proces, který se používá k zachycení těchto obrázků, z velké části stejný. To platí pro aplikace, které používají výchozí automatizované ovládací prvky fotoaparátu nebo aplikace, které využívají nové ovládací prvky Ruční Kamera:

Vstup je převzat z do AVCaptureDeviceInput objektu AVCaptureSession .AVCaptureConnection Výsledkem je buď výstup jako stále obrázek, nebo jako stream videa. Celý proces je řízen pomocí AVCaptureDevice.

K dispozici jsou ruční ovládací prvky

Pomocí nových rozhraní API poskytovaných iOSem 8 může aplikace převzít kontrolu nad následujícími funkcemi fotoaparátu:

Ruční fokus – Tím, že koncovému uživateli umožníte přímo převzít kontrolu nad fokusem, může aplikace poskytnout větší kontrolu nad pořízeným obrázkem.
Ruční expozice – Poskytnutím ruční kontroly nad expozicí může aplikace uživatelům poskytnout větší volnost a umožnit jim dosáhnout stylizovaného vzhledu.
Ruční vyvážení bílé barvy – Vyvážení bílé se používá k úpravě barvy na obrázku – často tak, aby vypadala realisticky. Různé zdroje světla mají různé barevné teploty a nastavení fotoaparátu použité k zachycení obrázku se upraví tak, aby tyto rozdíly kompenzovaly. Opět tím, že uživateli povolíte kontrolu nad vyvážením bílé barvy, můžou uživatelé provádět úpravy, které se nedají provést automaticky.

iOS 8 poskytuje rozšíření a vylepšení stávajících rozhraní API pro iOS, která poskytují tuto jemně odstupňovanou kontrolu nad procesem zachytávání obrázků.

Požadavky

K dokončení kroků uvedených v tomto článku jsou potřeba následující:

Xcode 7+ a iOS 8 nebo novější – na počítači vývojáře musí být nainstalovaná a nakonfigurovaná rozhraní API Xcode 7 a iOS 8 nebo novější.
Visual Studio pro Mac – Na uživatelském zařízení by se měla nainstalovat a nakonfigurovat nejnovější verze Visual Studio pro Mac.
Zařízení s iOSem 8 – zařízení s iOSem s nejnovější verzí iOS 8. Kamera funkce nelze testovat v simulátoru iOS.

Obecné nastavení zachytávání AV

Při nahrávání videa na zařízení s iOSem je vždy nutný nějaký obecný instalační kód. Tato část se zabývá minimálním nastavením, které je nutné k nahrávání videa z fotoaparátu zařízení s iOSem UIImageViewa zobrazení tohoto videa v reálném čase v aplikaci .

Delegát výstupní ukázkové vyrovnávací paměti

Jednou z prvníchvěcích UIImageView

Následující rutina bude monitorovat ukázkovou vyrovnávací paměť a aktualizovat uživatelské rozhraní:

using System;
using Foundation;
using UIKit;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Linq;
using AVFoundation;
using CoreVideo;
using CoreMedia;
using CoreGraphics;

namespace ManualCameraControls
{
    public class OutputRecorder : AVCaptureVideoDataOutputSampleBufferDelegate
    {
        #region Computed Properties
        public UIImageView DisplayView { get; set; }
        #endregion

        #region Constructors
        public OutputRecorder ()
        {

        }
        #endregion

        #region Private Methods
        private UIImage GetImageFromSampleBuffer(CMSampleBuffer sampleBuffer) {

            // Get a pixel buffer from the sample buffer
            using (var pixelBuffer = sampleBuffer.GetImageBuffer () as CVPixelBuffer) {
                // Lock the base address
                pixelBuffer.Lock (0);

                // Prepare to decode buffer
                var flags = CGBitmapFlags.PremultipliedFirst | CGBitmapFlags.ByteOrder32Little;

                // Decode buffer - Create a new colorspace
                using (var cs = CGColorSpace.CreateDeviceRGB ()) {

                    // Create new context from buffer
                    using (var context = new CGBitmapContext (pixelBuffer.BaseAddress,
                        pixelBuffer.Width,
                        pixelBuffer.Height,
                        8,
                        pixelBuffer.BytesPerRow,
                        cs,
                        (CGImageAlphaInfo)flags)) {

                        // Get the image from the context
                        using (var cgImage = context.ToImage ()) {

                            // Unlock and return image
                            pixelBuffer.Unlock (0);
                            return UIImage.FromImage (cgImage);
                        }
                    }
                }
            }
        }
        #endregion

        #region Override Methods
        public override void DidOutputSampleBuffer (AVCaptureOutput captureOutput, CMSampleBuffer sampleBuffer, AVCaptureConnection connection)
        {
            // Trap all errors
            try {
                // Grab an image from the buffer
                var image = GetImageFromSampleBuffer(sampleBuffer);

                // Display the image
                if (DisplayView !=null) {
                    DisplayView.BeginInvokeOnMainThread(() => {
                        // Set the image
                        if (DisplayView.Image != null) DisplayView.Image.Dispose();
                        DisplayView.Image = image;

                        // Rotate image to the correct display orientation
                        DisplayView.Transform = CGAffineTransform.MakeRotation((float)Math.PI/2);
                    });
                }

                // IMPORTANT: You must release the buffer because AVFoundation has a fixed number
                // of buffers and will stop delivering frames if it runs out.
                sampleBuffer.Dispose();
            }
            catch(Exception e) {
                // Report error
                Console.WriteLine ("Error sampling buffer: {0}", e.Message);
            }
        }
        #endregion
    }
}

Pomocí této rutiny AppDelegate je možné upravit, aby se otevřela relace záznamu AV, aby se nahrál kanál živého videa.

Vytvoření relace zachytávání AV

Relace záznamu AV se používá k řízení nahrávání živého videa z fotoaparátu zařízení s iOSem a vyžaduje se k tomu, aby se video dostalo do aplikace pro iOS. Vzhledem k tomu, že ukázková ManualCameraControl ukázková aplikace používá relaci zachycení na několika různých místech, nakonfiguruje se v AppDelegate celé aplikaci a zpřístupní se.

Následujícím postupem upravte aplikaci AppDelegate a přidejte potřebný kód:

Poklikáním na AppDelegate.cs soubor v Průzkumník řešení ho otevřete pro úpravy.

Na začátek souboru přidejte následující příkazy using:

using System;
using Foundation;
using UIKit;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Linq;
using AVFoundation;
using CoreVideo;
using CoreMedia;
using CoreGraphics;
using CoreFoundation;

Do třídy přidejte následující privátní proměnné a vypočítané vlastnosti AppDelegate :

#region Private Variables
private NSError Error;
#endregion

#region Computed Properties
public override UIWindow Window {get;set;}
public bool CameraAvailable { get; set; }
public AVCaptureSession Session { get; set; }
public AVCaptureDevice CaptureDevice { get; set; }
public OutputRecorder Recorder { get; set; }
public DispatchQueue Queue { get; set; }
public AVCaptureDeviceInput Input { get; set; }
#endregion

Přepište dokončenou metodu a změňte ji na:

public override void FinishedLaunching (UIApplication application)
{
    // Create a new capture session
    Session = new AVCaptureSession ();
    Session.SessionPreset = AVCaptureSession.PresetMedium;

    // Create a device input
    CaptureDevice = AVCaptureDevice.DefaultDeviceWithMediaType (AVMediaType.Video);
    if (CaptureDevice == null) {
        // Video capture not supported, abort
        Console.WriteLine ("Video recording not supported on this device");
        CameraAvailable = false;
        return;
    }

    // Prepare device for configuration
    CaptureDevice.LockForConfiguration (out Error);
    if (Error != null) {
        // There has been an issue, abort
        Console.WriteLine ("Error: {0}", Error.LocalizedDescription);
        CaptureDevice.UnlockForConfiguration ();
        return;
    }

    // Configure stream for 15 frames per second (fps)
    CaptureDevice.ActiveVideoMinFrameDuration = new CMTime (1, 15);

    // Unlock configuration
    CaptureDevice.UnlockForConfiguration ();

    // Get input from capture device
    Input = AVCaptureDeviceInput.FromDevice (CaptureDevice);
    if (Input == null) {
        // Error, report and abort
        Console.WriteLine ("Unable to gain input from capture device.");
        CameraAvailable = false;
        return;
    }

    // Attach input to session
    Session.AddInput (Input);

    // Create a new output
    var output = new AVCaptureVideoDataOutput ();
    var settings = new AVVideoSettingsUncompressed ();
    settings.PixelFormatType = CVPixelFormatType.CV32BGRA;
    output.WeakVideoSettings = settings.Dictionary;

    // Configure and attach to the output to the session
    Queue = new DispatchQueue ("ManCamQueue");
    Recorder = new OutputRecorder ();
    output.SetSampleBufferDelegate (Recorder, Queue);
    Session.AddOutput (output);

    // Let tabs know that a camera is available
    CameraAvailable = true;
}

Uložte změny souboru.

S tímto kódem je možné snadno implementovat ruční Kamera ovládací prvky pro experimentování a testování.

Ruční fokus

Díky tomu, že koncovému uživateli povolíte přímé řízení fokusu, může aplikace poskytnout větší kontrolu nad pořízeným obrázkem.

Profesionální fotograf může například změkčit fokus obrázku, aby dosáhl efektu Bokeh. Nebo můžete vytvořit efekt vyžádání fokusu.

Pro vědce nebo spisovatele lékařských aplikací může aplikace chtít programově přesouvat objektivy pro experimenty. Nové rozhraní API umožňuje koncovému uživateli nebo aplikaci převzít kontrolu nad fokusem v době pořízení obrázku.

Jak funguje fokus

Než začnete diskutovat o podrobnostech řízení zaměření v aplikaci iOS 8. Pojďme se rychle podívat, jak funguje fokus na zařízení s iOSem:

Světlo vstupuje do objektivu fotoaparátu na zařízení s iOSem a zaměřuje se na snímač obrazu. Vzdálenost objektivu od snímačů určuje, kde je fokus (oblast, kde se obrázek objeví nejostřeji), ve vztahu ke snímači. Čím dál je objektiv ze senzoru, objekty vzdálenosti vypadají nejostřeji a blíže, nejbližší objekty se zdají být nejostřejší.

V zařízení s iOSem se objektiv přesune blíž k snímači magnety a pružinami nebo dále od zařízení s iOSem. V důsledku toho je přesné umístění objektivu nemožné, protože se bude lišit od zařízení po zařízení a může být ovlivněno parametry, jako je orientace zařízení nebo stáří zařízení a pružiny.

Důležité termíny zaměření

Při práci s fokusem existuje několik termínů, které by měl vývojář znát:

Hloubka pole – vzdálenost mezi nejbližšími a nejbližšími objekty v fokusu.
Makro – Jedná se o nejbližší konec fokusu a je nejbližší vzdálenost, ve které se objektiv může zaměřit.
Nekonečno – Jedná se o zdaleka konec fokusového spektra a je to nejdůslednější vzdálenost, na které se objektiv může zaměřit.
Hyperfokální vzdálenost – Jedná se o bod v fokusu, kde nejdálnější objekt v rámci rámce je právě na konci fokusu. Jinými slovy, toto je ústřední pozice, která maximalizuje hloubku pole.
Pozice objektivu – To je to, co řídí všechny výše uvedené termíny. Jedná se o vzdálenost objektivu od senzoru a tím kontroleru fokusu.

S ohledem na tyto termíny a znalosti je možné úspěšně implementovat nové ovládací prvky ručního zaměření v aplikaci pro iOS 8.

Existující ovládací prvky fokusu

iOS 7 a starší verze poskytují stávající ovládací prvky focusu prostřednictvím FocusModevlastnosti jako:

AVCaptureFocusModeLocked – Fokus je uzamčený na jednom místě fokusu.
AVCaptureFocusModeAutoFocus – Fotoaparát zamítá objektiv přes všechny kontaktní body, dokud nenajde ostrý fokus a pak zůstane tam.
AVCaptureFocusModeContinuousAutoFocus – Fotoaparát refokusuje pokaždé, když zjistí stav mimo fokus.

Stávající ovládací prvky také poskytly nastavitelný bod zájmu prostřednictvímFocusPointOfInterest vlastnosti, aby uživatel mohl klepnout a zaměřit se na konkrétní oblast. Aplikace může také sledovat pohyb objektivu monitorováním IsAdjustingFocus vlastnosti.

Kromě toho vlastnost omezení rozsahu poskytla AutoFocusRangeRestriction takto:

AVCaptureAutoFocusRangeRestrictionNear – Omezuje automatické fokusy na okolní hloubky. Užitečné v situacích, jako je skenování kódu QR nebo čárového kódu.
AVCaptureAutoFocusRangeRestrictionFar – Omezuje automatické zaostření na vzdálené hloubky. Užitečné v situacích, kdy objekty, o kterých je známo, že jsou irelevantní, jsou v poli zobrazení (například v rámečku okna).

Nakonec je SmoothAutoFocus vlastnost, která zpomalí algoritmus automatického fokusu a provede kroky v menších přírůstcích, aby se zabránilo přesouvání artefaktů při nahrávání videa.

Nové ovládací prvky fokusu v iOSu 8

Kromě funkcí, které už iOS 7 a novější poskytuje, jsou teď k dispozici následující funkce pro ovládání fokusu v iOSu 8:

Úplné ruční ovládání pozice objektivu při zamknutí fokusu.
Pozorování klíčové hodnoty pozice objektivu v jakémkoli detailním režimu

K implementaci výše uvedených funkcí byla třída upravena tak, AVCaptureDevice aby zahrnovala vlastnost určenou jen LensPosition pro čtení, která slouží k získání aktuální pozice objektivu fotoaparátu.

Pokud chcete převzít ruční kontrolu nad polohou objektivu, musí být zařízení capture v zamčeném detailním režimu. Příklad:

CaptureDevice.FocusMode = AVCaptureFocusMode.Locked;

SetFocusModeLocked Metoda zařízení Capture se používá k úpravě polohy objektivu fotoaparátu. Volitelná rutina zpětného volání může být k dispozici pro získání oznámení, když se změna projeví. Příklad:

ThisApp.CaptureDevice.LockForConfiguration(out Error);
ThisApp.CaptureDevice.SetFocusModeLocked(Position.Value,null);
ThisApp.CaptureDevice.UnlockForConfiguration();

Jak je vidět na výše uvedeném kódu, musí být zařízení Capture uzamčeno pro konfiguraci, aby bylo možné provést změnu pozice objektivu. Platné hodnoty pozice objektivu jsou mezi 0,0 a 1,0.

Příklad ručního fokusu

Když je zaveden kód pro obecné nastavení zachytávání AV, UIViewController můžete ho přidat do scénáře aplikace a nakonfigurovat následujícím způsobem:

Zobrazení obsahuje následující hlavní prvky:

A UIImageView , která zobrazí informační kanál videa.
A UISegmentedControl , který změní detailní režim z automatické na uzamčený.
Zobrazí UISlider a aktualizuje aktuální pozici objektivu.

Pokud chcete připojit kontroler zobrazení pro ruční ovládání fokusu, postupujte takto:

Přidejte následující příkazy using:

using System;
using Foundation;
using UIKit;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Linq;
using AVFoundation;
using CoreVideo;
using CoreMedia;
using CoreGraphics;
using CoreFoundation;
using System.Timers;

Přidejte následující privátní proměnné:

#region Private Variables
private NSError Error;
private bool Automatic = true;
#endregion

Přidejte následující vypočítané vlastnosti:

#region Computed Properties
public AppDelegate ThisApp {
    get { return (AppDelegate)UIApplication.SharedApplication.Delegate; }
}
public Timer SampleTimer { get; set; }
#endregion

Přepište metodu ViewDidLoad a přidejte následující kód:

public override void ViewDidLoad ()
{
    base.ViewDidLoad ();

    // Hide no camera label
    NoCamera.Hidden = ThisApp.CameraAvailable;

    // Attach to camera view
    ThisApp.Recorder.DisplayView = CameraView;

    // Create a timer to monitor and update the UI
    SampleTimer = new Timer (5000);
    SampleTimer.Elapsed += (sender, e) => {
        // Update position slider
        Position.BeginInvokeOnMainThread(() =>{
            Position.Value = ThisApp.Input.Device.LensPosition;
        });
    };

    // Watch for value changes
    Segments.ValueChanged += (object sender, EventArgs e) => {

        // Lock device for change
        ThisApp.CaptureDevice.LockForConfiguration(out Error);

        // Take action based on the segment selected
        switch(Segments.SelectedSegment) {
        case 0:
            // Activate auto focus and start monitoring position
            Position.Enabled = false;
            ThisApp.CaptureDevice.FocusMode = AVCaptureFocusMode.ContinuousAutoFocus;
            SampleTimer.Start();
            Automatic = true;
            break;
        case 1:
            // Stop auto focus and allow the user to control the camera
            SampleTimer.Stop();
            ThisApp.CaptureDevice.FocusMode = AVCaptureFocusMode.Locked;
            Automatic = false;
            Position.Enabled = true;
            break;
        }

        // Unlock device
        ThisApp.CaptureDevice.UnlockForConfiguration();
    };

    // Monitor position changes
    Position.ValueChanged += (object sender, EventArgs e) => {

        // If we are in the automatic mode, ignore changes
        if (Automatic) return;

        // Update Focus position
        ThisApp.CaptureDevice.LockForConfiguration(out Error);
        ThisApp.CaptureDevice.SetFocusModeLocked(Position.Value,null);
        ThisApp.CaptureDevice.UnlockForConfiguration();
    };
}

Přepište metodu ViewDidAppear a přidejte následující, aby se spustil záznam při načtení zobrazení:

public override void ViewDidAppear (bool animated)
{
    base.ViewDidAppear (animated);

    // Start udating the display
    if (ThisApp.CameraAvailable) {
        // Remap to this camera view
        ThisApp.Recorder.DisplayView = CameraView;

        ThisApp.Session.StartRunning ();
        SampleTimer.Start ();
    }
}

Když je fotoaparát v automatickém režimu, posuvník se při úpravě fokusu automaticky přesune:
Klepněte na uzamčený segment a přetažením posuvníku pozice upravte pozici objektivu ručně:
Zastavte aplikaci.

Výše uvedený kód ukazuje, jak monitorovat polohu objektivu, když je fotoaparát v automatickém režimu, nebo pomocí posuvníku určit polohu objektivu, když je v uzamčeném režimu.

Ruční expozice

Expozice odkazuje na jas obrázku vzhledem ke zdrojovému jasu a je určena tím, kolik světla dosáhne senzoru, jak dlouho a na úrovni získání senzoru (mapování ISO). Poskytnutím ruční kontroly nad expozicí může aplikace poskytnout koncovému uživateli větší volnost a umožnit jim dosáhnout stylizovaného vzhledu.

Pomocí ovládacích prvků ruční expozice může uživatel pořídit obrázek z nerealisticky jasného na tmavé a náladové:

To lze provést automaticky pomocí programového řízení pro vědecké aplikace nebo prostřednictvím ručních ovládacích prvků poskytovaných uživatelským rozhraním aplikací. V obou směrech nové rozhraní API pro expozice iOS 8 poskytují jemně odstupňovanou kontrolu nad nastavením expozice fotoaparátu.

Jak funguje expozice

Než probereme podrobnosti o řízení expozice v aplikaci iOS 8. Pojďme se rychle podívat, jak expozice funguje:

Tři základní prvky, které se skládají k řízení expozice, jsou:

Rychlost závěrky – Doba, po kterou je spouštěná, aby se světlo nechalo na senzor fotoaparátu. Čím kratší je čas otevření závěrky, tím méně světla se nechá dovnitř a čím je obraz ostřejší (menší rozostření pohybu). Čím delší je závěrka otevřená, tím více světla se nechá dovnitř a tím více rozostření pohybu, ke kterému dochází.
MAPOVÁNÍ ISO – Jedná se o termín půjčený z filmových fotografií a odkazuje na citlivost chemických látek ve filmu na světlo. Nízké hodnoty ISO ve filmu mají méně zrnité a jemné barevné reprodukci; nízké hodnoty ISO u digitálních senzorů mají méně šumu senzoru, ale méně jasu. Čím vyšší je hodnota ISO, tím jasnější je obraz, ale s větším šumem senzoru. "ISO" digitálního senzoru je míra elektronického zisku, nikoli fyzické funkce.
Lens Lens – Jedná se o velikost otvoru objektivu. Na všech zařízeních s iOSem je clona objektivu pevná, takže jedinými dvěma hodnotami, které lze použít k úpravě expozice, jsou shutter Speed a ISO.

Jak funguje průběžné automatické vystavení

Než se naučíte, jak funguje ruční expozice, je vhodné pochopit, jak funguje nepřetržité automatické vystavení v zařízení s iOSem.

Za prvé je auto exposure block, má úlohu výpočtu ideální expozice a neustále se živuje statistiky měření. Tyto informace používají k výpočtu optimální kombinace ISO a rychlosti závěrky, aby se scéna dobře rozsvítit. Tento cyklus se označuje jako smyčka AE.

Jak funguje uzamčená expozice

Teď se podíváme, jak funguje uzamčená expozice v zařízeních s iOSem.

Opět máte blok automatické expozice, který se pokouší vypočítat optimální hodnoty pro iOS a dobu trvání. V tomto režimu je však blok AE odpojen od modulu statistik měření.

Stávající ovládací prvky expozice

iOS 7 a vyšší poskytují následující existující ovládací prvky expozice prostřednictvím ExposureMode vlastnosti:

AVCaptureExposureModeLocked – Ukázky scény jednou a používají tyto hodnoty v celé scéně.
AVCaptureExposureModeContinuousAutoExposure – Vzorkuje scénu nepřetržitě, aby se zajistilo, že je dobře osvětlená.

Pomocí ExposurePointOfInterest klepnutí můžete zobrazit scénu tak, že vyberete cílový objekt, na který se má vystavit, a aplikace může vlastnost monitorovat AdjustingExposure , aby viděla, kdy se expozice upravuje.

Nové ovládací prvky expozice v iOSu 8

Kromě funkcí, které už iOS 7 a novější poskytuje, jsou nyní k dispozici následující funkce pro řízení expozice v iOSu 8:

Plně ruční vlastní expozice.
Získání, nastavení a sledování rychlosti závěrky (Doba trvání) pro iOS a klíč-hodnota

K implementaci výše uvedených funkcí jsme přidali nový AVCaptureExposureModeCustom režim. Pokud je fotoaparát v vlastním režimu, můžete k úpravě doby trvání expozice a ISO použít následující kód:

CaptureDevice.LockForConfiguration(out Error);
CaptureDevice.LockExposure(DurationValue,ISOValue,null);
CaptureDevice.UnlockForConfiguration();

V režimech Automatické a uzamčené aplikace může upravit předsudky rutiny automatické expozice pomocí následujícího kódu:

CaptureDevice.LockForConfiguration(out Error);
CaptureDevice.SetExposureTargetBias(Value,null);
CaptureDevice.UnlockForConfiguration();

Minimální a maximální rozsahy nastavení závisí na zařízení, na kterém aplikace běží, takže by nikdy neměly být pevně zakódované. Místo toho pomocí následujících vlastností získejte minimální a maximální rozsahy hodnot:

CaptureDevice.MinExposureTargetBias
CaptureDevice.MaxExposureTargetBias
CaptureDevice.ActiveFormat.MinISO
CaptureDevice.ActiveFormat.MaxISO
CaptureDevice.ActiveFormat.MinExposureDuration
CaptureDevice.ActiveFormat.MaxExposureDuration

Jak je vidět na výše uvedeném kódu, musí být zařízení capture uzamčeno pro konfiguraci, aby bylo možné provést změnu expozice.

Příklad ruční expozice

Když je zaveden kód pro obecné nastavení zachytávání AV, UIViewController můžete ho přidat do scénáře aplikace a nakonfigurovat následujícím způsobem:

Zobrazení obsahuje následující hlavní prvky:

A UIImageView , která zobrazí informační kanál videa.
A UISegmentedControl , který změní detailní režim z automatické na uzamčený.
Čtyři UISlider ovládací prvky, které zobrazí a aktualizují posun, dobu trvání, ISO a předsudky.

Pomocí následujícího návodu pro ruční řízení expozice proveďte připojení kontroleru zobrazení:

Přidejte následující příkazy using:

using System;
using Foundation;
using UIKit;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Linq;
using AVFoundation;
using CoreVideo;
using CoreMedia;
using CoreGraphics;
using CoreFoundation;
using System.Timers;

Přidejte následující privátní proměnné:

#region Private Variables
private NSError Error;
private bool Automatic = true;
private nfloat ExposureDurationPower = 5;
private nfloat ExposureMinimumDuration = 1.0f/1000.0f;
#endregion

Přidejte následující vypočítané vlastnosti:

#region Computed Properties
public AppDelegate ThisApp {
    get { return (AppDelegate)UIApplication.SharedApplication.Delegate; }
}
public Timer SampleTimer { get; set; }
#endregion

Přepište metodu ViewDidLoad a přidejte následující kód:

public override void ViewDidLoad ()
{
    base.ViewDidLoad ();

    // Hide no camera label
    NoCamera.Hidden = ThisApp.CameraAvailable;

    // Attach to camera view
    ThisApp.Recorder.DisplayView = CameraView;

    // Set min and max values
    Offset.MinValue = ThisApp.CaptureDevice.MinExposureTargetBias;
    Offset.MaxValue = ThisApp.CaptureDevice.MaxExposureTargetBias;

    Duration.MinValue = 0.0f;
    Duration.MaxValue = 1.0f;

    ISO.MinValue = ThisApp.CaptureDevice.ActiveFormat.MinISO;
    ISO.MaxValue = ThisApp.CaptureDevice.ActiveFormat.MaxISO;

    Bias.MinValue = ThisApp.CaptureDevice.MinExposureTargetBias;
    Bias.MaxValue = ThisApp.CaptureDevice.MaxExposureTargetBias;

    // Create a timer to monitor and update the UI
    SampleTimer = new Timer (5000);
    SampleTimer.Elapsed += (sender, e) => {
        // Update position slider
        Offset.BeginInvokeOnMainThread(() =>{
            Offset.Value = ThisApp.Input.Device.ExposureTargetOffset;
        });

        Duration.BeginInvokeOnMainThread(() =>{
            var newDurationSeconds = CMTimeGetSeconds(ThisApp.Input.Device.ExposureDuration);
            var minDurationSeconds = Math.Max(CMTimeGetSeconds(ThisApp.CaptureDevice.ActiveFormat.MinExposureDuration), ExposureMinimumDuration);
            var maxDurationSeconds = CMTimeGetSeconds(ThisApp.CaptureDevice.ActiveFormat.MaxExposureDuration);
            var p = (newDurationSeconds - minDurationSeconds) / (maxDurationSeconds - minDurationSeconds);
            Duration.Value = (float)Math.Pow(p, 1.0f/ExposureDurationPower);
        });

        ISO.BeginInvokeOnMainThread(() => {
            ISO.Value = ThisApp.Input.Device.ISO;
        });

        Bias.BeginInvokeOnMainThread(() => {
            Bias.Value = ThisApp.Input.Device.ExposureTargetBias;
        });
    };

    // Watch for value changes
    Segments.ValueChanged += (object sender, EventArgs e) => {

        // Lock device for change
        ThisApp.CaptureDevice.LockForConfiguration(out Error);

        // Take action based on the segment selected
        switch(Segments.SelectedSegment) {
        case 0:
            // Activate auto exposure and start monitoring position
            Duration.Enabled = false;
            ISO.Enabled = false;
            ThisApp.CaptureDevice.ExposureMode = AVCaptureExposureMode.ContinuousAutoExposure;
            SampleTimer.Start();
            Automatic = true;
            break;
        case 1:
            // Lock exposure and allow the user to control the camera
            SampleTimer.Stop();
            ThisApp.CaptureDevice.ExposureMode = AVCaptureExposureMode.Locked;
            Automatic = false;
            Duration.Enabled = false;
            ISO.Enabled = false;
            break;
        case 2:
            // Custom exposure and allow the user to control the camera
            SampleTimer.Stop();
            ThisApp.CaptureDevice.ExposureMode = AVCaptureExposureMode.Custom;
            Automatic = false;
            Duration.Enabled = true;
            ISO.Enabled = true;
            break;
        }

        // Unlock device
        ThisApp.CaptureDevice.UnlockForConfiguration();
    };

    // Monitor position changes
    Duration.ValueChanged += (object sender, EventArgs e) => {

        // If we are in the automatic mode, ignore changes
        if (Automatic) return;

        // Calculate value
        var p = Math.Pow(Duration.Value,ExposureDurationPower);
        var minDurationSeconds = Math.Max(CMTimeGetSeconds(ThisApp.CaptureDevice.ActiveFormat.MinExposureDuration),ExposureMinimumDuration);
        var maxDurationSeconds = CMTimeGetSeconds(ThisApp.CaptureDevice.ActiveFormat.MaxExposureDuration);
        var newDurationSeconds = p * (maxDurationSeconds - minDurationSeconds) +minDurationSeconds;

        // Update Focus position
        ThisApp.CaptureDevice.LockForConfiguration(out Error);
        ThisApp.CaptureDevice.LockExposure(CMTime.FromSeconds(p,1000*1000*1000),ThisApp.CaptureDevice.ISO,null);
        ThisApp.CaptureDevice.UnlockForConfiguration();
    };

    ISO.ValueChanged += (object sender, EventArgs e) => {

        // If we are in the automatic mode, ignore changes
        if (Automatic) return;

        // Update Focus position
        ThisApp.CaptureDevice.LockForConfiguration(out Error);
        ThisApp.CaptureDevice.LockExposure(ThisApp.CaptureDevice.ExposureDuration,ISO.Value,null);
        ThisApp.CaptureDevice.UnlockForConfiguration();
    };

    Bias.ValueChanged += (object sender, EventArgs e) => {

        // If we are in the automatic mode, ignore changes
        // if (Automatic) return;

        // Update Focus position
        ThisApp.CaptureDevice.LockForConfiguration(out Error);
        ThisApp.CaptureDevice.SetExposureTargetBias(Bias.Value,null);
        ThisApp.CaptureDevice.UnlockForConfiguration();
    };
}

Přepište metodu ViewDidAppear a přidejte následující, aby se spustil záznam při načtení zobrazení:

public override void ViewDidAppear (bool animated)
{
    base.ViewDidAppear (animated);

    // Start udating the display
    if (ThisApp.CameraAvailable) {
        // Remap to this camera view
        ThisApp.Recorder.DisplayView = CameraView;

        ThisApp.Session.StartRunning ();
        SampleTimer.Start ();
    }
}

S fotoaparátem v automatickém režimu se posuvníky automaticky přesunou, jakmile fotoaparát upraví expozici:
Klepněte na uzamčený segment a přetažením posuvníku předsudků upravte předsudky automatické expozice ručně:
Klepněte na vlastní segment a přetažením posuvníků Doba trvání a ISO ručně řídit expozici:
Zastavte aplikaci.

Výše uvedený kód ukázal, jak monitorovat nastavení expozice, když je fotoaparát v automatickém režimu, a jak pomocí posuvníků řídit expozici, když je v uzamčených nebo vlastních režimech.

Ruční vyvážení bílé

Ovládací prvky White Balance umožňují uživatelům upravit rovnováhu kolosu na obrázku, aby vypadaly realističtější. Různé zdroje světla mají různé barevné teploty a nastavení kamery použité k zachycení obrázku musí být upraveno tak, aby se tyto rozdíly vyrovnávaly. Opět tím, že umožníte uživateli kontrolu nad vyvážením bílé barvy, může provádět profesionální úpravy, které automatické rutiny nemohou dosáhnout uměleckých efektů.

Například denní světlo má modré přetypování, zatímco tungsten inkascentní světla mají teplejší, žluto oranžový odstín. (Matoucí, "studené" barvy mají vyšší teploty barev než "teplé" barvy. Barevné teploty jsou fyzickou mírou, nikoli perceptuální teplotou.)

Lidská mysl je velmi dobrá při kompenzaci rozdílů v teplotě barev, ale to je něco, co fotoaparát nemůže udělat. Fotoaparát funguje zvýšením barvy na opačném spektru, aby se upravily rozdíly barev.

Nové rozhraní API pro expozice iOS 8 umožňuje aplikaci převzít kontrolu nad procesem a zajistit jemně odstupňovanou kontrolu nad nastavením vyvážení bílé váhy fotoaparátu.

Jak funguje white balance

Než začnete diskutovat o podrobnostech řízení vyvážení bílé v aplikaci iOS 8. Pojďme se rychle podívat, jak funguje vyvážení bílé:

Ve studii vnímání barev jsou barevný prostor CIE 1931 RGB a barevný prostor CIE 1931 XYZ první matematicky definované barevné prostory. V roce 1931 byly vytvořeny Mezinárodní komisí pro osvětlení (CIE).

Výše uvedený graf ukazuje všechny barvy viditelné pro lidské oko, od hluboké modré až po jasně zelenou až jasně červenou. Libovolný bod v diagramu lze vykreslit s hodnotou X a Y, jak je znázorněno na výše uvedeném grafu.

Jak je vidět v grafu, existují hodnoty X a Y, které se dají vykreslit na grafu, které by byly mimo rozsah lidského zraku, a v důsledku toho není možné tyto barvy reprodukovat fotoaparátem.

Menší křivka ve výše uvedeném grafu se nazývá Planckian Barbar, který vyjadřuje barevnou teplotu (ve stupních kelvin), s vyššími čísly na modré straně (horká) a nižšími čísly na červené straně (chladič). To je užitečné pro typické situace osvětlení.

Ve smíšených světelných podmínkách se úpravy vyvážení bílé váhy budou muset odchýlit od planckovského Elementu, aby bylo nutné provést požadované změny. V těchto situacích bude nutné změnu posunout buď na zelenou, nebo červenou/purpurové straně měřítka CIE.

Zařízení s iOSem kompenzují barevné přetypování zvýšením opačné barvy. Pokud má scéna například příliš mnoho modrého, červený zisk se zvýší, aby se kompenzoval. Tyto hodnoty získání jsou kalibrovány pro konkrétní zařízení, takže jsou závislé na zařízení.

Existující ovládací prvky white balance

iOS 7 a vyšší poskytují následující existující ovládací prvky White Balance prostřednictvím WhiteBalanceMode vlastnosti:

AVCapture WhiteBalance ModeLocked – Ukázky scény jednou a použití těchto hodnot v celé scéně.
AVCapture WhiteBalance ModeContinuousAutoExposure – Vzorkuje scénu nepřetržitě, aby se zajistilo, že je dobře vyvážená.

A aplikace může AdjustingWhiteBalance sledovat vlastnost, aby viděla, kdy je expozice upravena.

Nové ovládací prvky white balance v iOSu 8

Kroměfunkcích

Plně ruční ovládání zařízení rgb zisky.
Získání, nastavení a klíč-hodnota Pozorujte zisky RGB zařízení.
Podpora vyvážení bílé barvy pomocí šedé karty
Konverzní rutiny do a z nezávislých barevných prostorů zařízení.

Pro implementaci výše uvedených funkcí AVCaptureWhiteBalanceGain byla struktura přidána s následujícími členy:

RedGain
GreenGain
BlueGain

Maximální zisk bílé rovnováhy je v současné době čtyři (4) a může být připraven z nemovitosti MaxWhiteBalanceGain . Právní rozsah je tedy v současné době od jednoho (1) do MaxWhiteBalanceGain (4).

Vlastnost DeviceWhiteBalanceGains lze použít ke sledování aktuálních hodnot. Slouží SetWhiteBalanceModeLockedWithDeviceWhiteBalanceGains k úpravě zůstatku, když je fotoaparát v zamknutém režimu vyvážení bílé barvy.

Rutiny převodu

Do iOSu 8 byly přidány rutiny převodu, které pomáhají s převodem na a z nezávislých barevných prostorů zařízení. Pro implementaci konverzních AVCaptureWhiteBalanceChromaticityValues rutin byla struktura přidána s následujícími členy:

X - je hodnota od 0 do 1.
Y - je hodnota od 0 do 1.

Byla AVCaptureWhiteBalanceTemperatureAndTintValues přidána také struktura s následujícími členy:

Temperature - je hodnota s plovoucí desetinnou čárkou ve stupních Kelvin.
Tint - je posun ze zelené nebo purpurové od 0 do 150 s kladnými hodnotami směrem k zelenému směru a negativním směrem k purpurové.

CaptureDevice.GetTemperatureAndTintValuesPomocí metod a CaptureDevice.GetDeviceWhiteBalanceGainsmetod můžete převést mezi teplotou a nádechem, chromatičností a RGB získat barevné prostory.

Poznámka:

Konverzní rutiny jsou přesnější, čím blíže je hodnota, která se má převést, je na Planckian Automaticky.

Podpora šedé karty

Apple používá termín Gray World k odkaz na podporu šedé karty integrované do iOS 8. Umožňuje uživateli zaměřit se na fyzickou šedou kartu, která pokrývá alespoň 50 % středu rámečku a používá ji k úpravě white balance. Účelem šedé karty je dosáhnout bílé, která se zobrazuje neutrální.

To lze implementovat v aplikaci tak, že uživatele vyzve, aby před fotoaparátem umístil fyzickou šedou kartu, monitoroval GrayWorldDeviceWhiteBalanceGains vlastnost a čekal, dokud se hodnoty nezarovnávají.

Aplikace pak uzamkne zisky white balance pro metodu SetWhiteBalanceModeLockedWithDeviceWhiteBalanceGains pomocí hodnot z GrayWorldDeviceWhiteBalanceGains vlastnosti, aby se změny použily.

Aby bylo možné provést změnu v nástroji White Balance, musí být zařízení pro zachytávání uzamčeno pro konfiguraci.

Příklad ručního vyvážení white balance

Když je zaveden kód pro obecné nastavení zachytávání AV, UIViewController můžete ho přidat do scénáře aplikace a nakonfigurovat následujícím způsobem:

Zobrazení obsahuje následující hlavní prvky:

A UIImageView , která zobrazí informační kanál videa.
A UISegmentedControl , který změní detailní režim z automatické na uzamčený.
Dva UISlider ovládací prvky, které zobrazí a aktualizují teplotu a nádech.
A UIButton used to sample a Gray Card (Gray World) space and set the White Balance using the values.

Pokud chcete připojit kontroler zobrazení pro ruční řízení vyvážení bílé váhy, postupujte takto:

Přidejte následující příkazy using:

using System;
using Foundation;
using UIKit;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Linq;
using AVFoundation;
using CoreVideo;
using CoreMedia;
using CoreGraphics;
using CoreFoundation;
using System.Timers;

Přidejte následující privátní proměnné:

#region Private Variables
private NSError Error;
private bool Automatic = true;
#endregion

Přidejte následující vypočítané vlastnosti:

#region Computed Properties
public AppDelegate ThisApp {
    get { return (AppDelegate)UIApplication.SharedApplication.Delegate; }
}
public Timer SampleTimer { get; set; }
#endregion

Přidejte následující privátní metodu, která nastaví novou hodnotu White Balance Temperature and Tint:

#region Private Methods
void SetTemperatureAndTint() {
    // Grab current temp and tint
    var TempAndTint = new AVCaptureWhiteBalanceTemperatureAndTintValues (Temperature.Value, Tint.Value);

    // Convert Color space
    var gains = ThisApp.CaptureDevice.GetDeviceWhiteBalanceGains (TempAndTint);

    // Set the new values
    if (ThisApp.CaptureDevice.LockForConfiguration (out Error)) {
        gains = NomralizeGains (gains);
        ThisApp.CaptureDevice.SetWhiteBalanceModeLockedWithDeviceWhiteBalanceGains (gains, null);
        ThisApp.CaptureDevice.UnlockForConfiguration ();
    }
}

AVCaptureWhiteBalanceGains NomralizeGains (AVCaptureWhiteBalanceGains gains)
{
    gains.RedGain = Math.Max (1, gains.RedGain);
    gains.BlueGain = Math.Max (1, gains.BlueGain);
    gains.GreenGain = Math.Max (1, gains.GreenGain);

    float maxGain = ThisApp.CaptureDevice.MaxWhiteBalanceGain;
    gains.RedGain = Math.Min (maxGain, gains.RedGain);
    gains.BlueGain = Math.Min (maxGain, gains.BlueGain);
    gains.GreenGain = Math.Min (maxGain, gains.GreenGain);

    return gains;
}
#endregion

Přepište metodu ViewDidLoad a přidejte následující kód:

public override void ViewDidLoad ()
{
    base.ViewDidLoad ();

    // Hide no camera label
    NoCamera.Hidden = ThisApp.CameraAvailable;

    // Attach to camera view
    ThisApp.Recorder.DisplayView = CameraView;

    // Set min and max values
    Temperature.MinValue = 1000f;
    Temperature.MaxValue = 10000f;

    Tint.MinValue = -150f;
    Tint.MaxValue = 150f;

    // Create a timer to monitor and update the UI
    SampleTimer = new Timer (5000);
    SampleTimer.Elapsed += (sender, e) => {
        // Convert color space
        var TempAndTint = ThisApp.CaptureDevice.GetTemperatureAndTintValues (ThisApp.CaptureDevice.DeviceWhiteBalanceGains);

        // Update slider positions
        Temperature.BeginInvokeOnMainThread (() => {
            Temperature.Value = TempAndTint.Temperature;
        });

        Tint.BeginInvokeOnMainThread (() => {
            Tint.Value = TempAndTint.Tint;
        });
    };

    // Watch for value changes
    Segments.ValueChanged += (sender, e) => {
        // Lock device for change
        if (ThisApp.CaptureDevice.LockForConfiguration (out Error)) {

            // Take action based on the segment selected
            switch (Segments.SelectedSegment) {
            case 0:
            // Activate auto focus and start monitoring position
                Temperature.Enabled = false;
                Tint.Enabled = false;
                ThisApp.CaptureDevice.WhiteBalanceMode = AVCaptureWhiteBalanceMode.ContinuousAutoWhiteBalance;
                SampleTimer.Start ();
                Automatic = true;
                break;
            case 1:
            // Stop auto focus and allow the user to control the camera
                SampleTimer.Stop ();
                ThisApp.CaptureDevice.WhiteBalanceMode = AVCaptureWhiteBalanceMode.Locked;
                Automatic = false;
                Temperature.Enabled = true;
                Tint.Enabled = true;
                break;
            }

            // Unlock device
            ThisApp.CaptureDevice.UnlockForConfiguration ();
        }
    };

    // Monitor position changes
    Temperature.TouchUpInside += (sender, e) => {

        // If we are in the automatic mode, ignore changes
        if (Automatic)
            return;

        // Update white balance
        SetTemperatureAndTint ();
    };

    Tint.TouchUpInside += (sender, e) => {

        // If we are in the automatic mode, ignore changes
        if (Automatic)
            return;

        // Update white balance
        SetTemperatureAndTint ();
    };

    GrayCardButton.TouchUpInside += (sender, e) => {

        // If we are in the automatic mode, ignore changes
        if (Automatic)
            return;

        // Get gray card values
        var gains = ThisApp.CaptureDevice.GrayWorldDeviceWhiteBalanceGains;

        // Set the new values
        if (ThisApp.CaptureDevice.LockForConfiguration (out Error)) {
            ThisApp.CaptureDevice.SetWhiteBalanceModeLockedWithDeviceWhiteBalanceGains (gains, null);
            ThisApp.CaptureDevice.UnlockForConfiguration ();
        }
    };
}

Přepište metodu ViewDidAppear a přidejte následující, aby se spustil záznam při načtení zobrazení:

public override void ViewDidAppear (bool animated)
{
    base.ViewDidAppear (animated);

    // Start udating the display
    if (ThisApp.CameraAvailable) {
        // Remap to this camera view
        ThisApp.Recorder.DisplayView = CameraView;

        ThisApp.Session.StartRunning ();
        SampleTimer.Start ();
    }
}

Uložte změny kódu a spusťte aplikaci.
S fotoaparátem v automatickém režimu se posuvníky automaticky přesunou, protože fotoaparát upravuje vyvážení bílé barvy:
Klepněte na uzamčený segment a přetažením posuvníků Temp a Tint upravte vyvážení bílé ručně:
Když je segment Uzamčený stále vybraný, umístěte před kameru fyzickou šedou kartu a klepnutím na tlačítko Šedá karta upravte bílý zůstatek na šedém světě:
Zastavte aplikaci.

Výše uvedený kód ukázal, jak monitorovat nastavení vyvážení bílé, když je fotoaparát v automatickém režimu, nebo pomocí posuvníků řídit vyvážení bílé, když je v uzamčeném režimu.

Zachytávání závorek

Funkce Bracketed Capture je založená na nastaveních z ovládacích prvků ručně Kamera uvedených výše a umožňuje aplikaci zachytit okamžik v čase, a to různými způsoby.

Jednoduše řečeno, Bracketed Capture je shluk stále pořízených s různými nastaveními od obrázku po obrázek.

Pomocí funkce Bracketed Capture v iOSu 8 může aplikace nastavit řadu ovládacích prvků ručně Kamera, vydat jeden příkaz a aktuální scénu vrátit řadu obrázků pro každou z ručních předvoleb.

Základní informace o zachytávání v hranatých závorkách

Funkce Bracketed Capture je opět nárůstem snímků pořízených různými nastaveními od obrázku po obrázek. K dispozici jsou typy závorek Capture:

Auto Exposure Bracket – kde všechny obrázky mají různou velikost zkreslení.
Ručně vystavená hranatá závorka – kde všechny obrázky mají různou rychlost závěrky (Doba trvání) a velikost ISO.
Jednoduchá shluková hranatá závorka – řada stále pořízených snímků v rychlém sledu.

Nové ovládací prvky zachycení v hranatých závorkách v iOSu 8

Všechny příkazy Capture v hranatých AVCaptureStillImageOutput závorkách jsou implementovány ve třídě. CaptureStillImageBracketPomocí této metody získáte řadu obrázků s daným polem nastavení.

Byly implementovány dvě nové třídy pro zpracování nastavení:

AVCaptureAutoExposureBracketedStillImageSettings – Má jednu vlastnost, ExposureTargetBiaskterá slouží k nastavení předsudků pro auto expozice hranaté závorky.
AVCaptureManualExposureBracketedStillImageSettings – Má dvě vlastnosti a ExposureDurationISOslouží k nastavení rychlosti závěrky a ISO pro ručně vystavenou závorku.

Ovládací prvky zachycení v hranatých závorkách a Ne

Do's

Následuje seznam věcí, které byste měli udělat při použití ovládacích prvků Bracketed Capture v iOSu 8:

Připravte aplikaci na nejhorší situaci zachycení voláním PrepareToCaptureStillImageBracket metody.
Předpokládejme, že ukázkové vyrovnávací paměti budou pocházet ze stejného sdíleného fondu.
Pokud chcete uvolnit paměť přidělenou předchozím voláním přípravy, zavolejte PrepareToCaptureStillImageBracket znovu a odešlete matici jednoho objektu.

Nedělat

Následuje seznam věcí, které by se neměly provádět při použití ovládacích prvků Bracketed Capture v iOSu 8:

Nekombinujte typy nastavení Bracketed Capture v jediném záznamu.
V jednom snímku nepožadujte více než MaxBracketedCaptureStillImageCount obrázky.

Podrobnosti záznamu v hranatých závorkách

Při práci s bracketed Capture v iOSu 8 byste měli vzít v úvahu následující podrobnosti:

Nastavení v hranatých závorkách dočasně přepíší AVCaptureDevice nastavení.
Nastavení stabilizace obrazu flash a nastavení stabilizace obrazu se ignoruje.
Všechny obrázky musí používat stejný výstupní formát (jpeg, png atd.).
Náhled videa může vypustit snímky.
Funkce Bracketed Capture je podporována na všech zařízeních kompatibilních s iOSem 8.

S ohledem na tyto informace se podíváme na příklad použití Bracketed Capture v iOSu 8.

Příklad zachycení závorek

Když je zaveden kód pro obecné nastavení zachytávání AV, UIViewController můžete ho přidat do scénáře aplikace a nakonfigurovat následujícím způsobem:

Zobrazení obsahuje následující hlavní prvky:

A UIImageView , která zobrazí informační kanál videa.
Tři UIImageViews , které zobrazí výsledky zachycení.
A UIScrollView pro zobrazení informačního kanálu videa a výsledků.
A UIButton used to take a Bracketed Capture with some preset settings.

Pokud chcete připojit kontroler zobrazení pro bracketed Capture, proveďte následující kroky:

Přidejte následující příkazy using:

using System;
using System.Drawing;
using Foundation;
using UIKit;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Linq;
using AVFoundation;
using CoreVideo;
using CoreMedia;
using CoreGraphics;
using CoreFoundation;
using CoreImage;

Přidejte následující privátní proměnné:

#region Private Variables
private NSError Error;
private List<UIImageView> Output = new List<UIImageView>();
private nint OutputIndex = 0;
#endregion

Přidejte následující vypočítané vlastnosti:

#region Computed Properties
public AppDelegate ThisApp {
    get { return (AppDelegate)UIApplication.SharedApplication.Delegate; }
}
#endregion

Přidejte následující privátní metodu pro sestavení požadovaných zobrazení výstupních imagí:

#region Private Methods
private UIImageView BuildOutputView(nint n) {

    // Create a new image view controller
    var imageView = new UIImageView (new CGRect (CameraView.Frame.Width * n, 0, CameraView.Frame.Width, CameraView.Frame.Height));

    // Load a temp image
    imageView.Image = UIImage.FromFile ("Default-568h@2x.png");

    // Add a label
    UILabel label = new UILabel (new CGRect (0, 20, CameraView.Frame.Width, 24));
    label.TextColor = UIColor.White;
    label.Text = string.Format ("Bracketed Image {0}", n);
    imageView.AddSubview (label);

    // Add to scrolling view
    ScrollView.AddSubview (imageView);

    // Return new image view
    return imageView;
}
#endregion

Přepište metodu ViewDidLoad a přidejte následující kód:

public override void ViewDidLoad ()
{
    base.ViewDidLoad ();

    // Hide no camera label
    NoCamera.Hidden = ThisApp.CameraAvailable;

    // Attach to camera view
    ThisApp.Recorder.DisplayView = CameraView;

    // Setup scrolling area
    ScrollView.ContentSize = new SizeF (CameraView.Frame.Width * 4, CameraView.Frame.Height);

    // Add output views
    Output.Add (BuildOutputView (1));
    Output.Add (BuildOutputView (2));
    Output.Add (BuildOutputView (3));

    // Create preset settings
    var Settings = new AVCaptureBracketedStillImageSettings[] {
        AVCaptureAutoExposureBracketedStillImageSettings.Create(-2.0f),
        AVCaptureAutoExposureBracketedStillImageSettings.Create(0.0f),
        AVCaptureAutoExposureBracketedStillImageSettings.Create(2.0f)
    };

    // Wireup capture button
    CaptureButton.TouchUpInside += (sender, e) => {
        // Reset output index
        OutputIndex = 0;

        // Tell the camera that we are getting ready to do a bracketed capture
        ThisApp.StillImageOutput.PrepareToCaptureStillImageBracket(ThisApp.StillImageOutput.Connections[0],Settings,async (bool ready, NSError err) => {
            // Was there an error, if so report it
            if (err!=null) {
                Console.WriteLine("Error: {0}",err.LocalizedDescription);
            }
        });

        // Ask the camera to snap a bracketed capture
        ThisApp.StillImageOutput.CaptureStillImageBracket(ThisApp.StillImageOutput.Connections[0],Settings, (sampleBuffer, settings, err) =>{
            // Convert raw image stream into a Core Image Image
            var imageData = AVCaptureStillImageOutput.JpegStillToNSData(sampleBuffer);
            var image = CIImage.FromData(imageData);

            // Display the resulting image
            Output[OutputIndex++].Image = UIImage.FromImage(image);

            // IMPORTANT: You must release the buffer because AVFoundation has a fixed number
            // of buffers and will stop delivering frames if it runs out.
            sampleBuffer.Dispose();
        });
    };
}

Přepište metodu ViewDidAppear a přidejte následující kód:

public override void ViewDidAppear (bool animated)
{
    base.ViewDidAppear (animated);

    // Start udating the display
    if (ThisApp.CameraAvailable) {
        // Remap to this camera view
        ThisApp.Recorder.DisplayView = CameraView;

        ThisApp.Session.StartRunning ();
    }
}

Uložte změny kódu a spusťte aplikaci.
Zarámujte scénu a klepněte na tlačítko Zachytit závorku:
Potáhnutím prstem doprava doleva zobrazíte tři snímky pořízené závorkami:
Zastavte aplikaci.

Výše uvedený kód ukázal, jak nakonfigurovat a převzít funkci Auto Exposure Bracketed Capture v iOSu 8.

Shrnutí

V tomto článku jsme se seznámili s novými ovládacími prvky ručního Kamera, které poskytuje iOS 8, a probrali jsme základy toho, co dělají a jak fungují. Poskytli jsme příklady ručního zaměření, ruční expozice a ručního vyvážení white balance. Nakonec jsme uvedli příklad použití závorky capture pomocí dříve probíraných ovládacích prvků ručně Kamera

Úvod do iOSu 8

Ruční ovládací prvky Kamera v Xamarin.iOS

Zachytávání objektů AVFoundation

K dispozici jsou ruční ovládací prvky

Požadavky

Obecné nastavení zachytávání AV

Delegát výstupní ukázkové vyrovnávací paměti

Vytvoření relace zachytávání AV

Ruční fokus

Jak funguje fokus

Důležité termíny zaměření

Existující ovládací prvky fokusu

Nové ovládací prvky fokusu v iOSu 8

Příklad ručního fokusu

Ruční expozice

Jak funguje expozice

Jak funguje průběžné automatické vystavení

Jak funguje uzamčená expozice

Stávající ovládací prvky expozice

Nové ovládací prvky expozice v iOSu 8

Příklad ruční expozice

Ruční vyvážení bílé

Jak funguje white balance

Existující ovládací prvky white balance

Nové ovládací prvky white balance v iOSu 8

Rutiny převodu

Podpora šedé karty

Příklad ručního vyvážení white balance

Zachytávání závorek

Základní informace o zachytávání v hranatých závorkách

Nové ovládací prvky zachycení v hranatých závorkách v iOSu 8

Ovládací prvky zachycení v hranatých závorkách a Ne

Do's

Nedělat

Podrobnosti záznamu v hranatých závorkách

Příklad zachycení závorek

Shrnutí

Související odkazy

Další materiály