Package apple.coreimage

Class CIImageProcessorKernel

  • All Implemented Interfaces:
    NSObject
    public class CIImageProcessorKernel
extends NSObject
    In order to use a CIImageProcessorInput & CIImageProcessorOutput you must subclass from a CIImageProcessorKernel and override the methods you need to produce the desired output.

    • Constructor Detail

      • CIImageProcessorKernel

        protected CIImageProcessorKernel​(org.moe.natj.general.Pointer peer)

    • Method Detail

      • accessInstanceVariablesDirectly

        public static boolean accessInstanceVariablesDirectly()

      • allocWithZone

        public static CIImageProcessorKernel allocWithZone​(org.moe.natj.general.ptr.VoidPtr zone)

      • applyWithExtentInputsArgumentsError

        @Nullable
public static @Nullable CIImage applyWithExtentInputsArgumentsError​(CGRect extent,
                                                                    @Nullable
                                                                    @Nullable NSArray<? extends CIImage> inputs,
                                                                    @Nullable
                                                                    @Nullable NSDictionary<java.lang.String,​?> args,
                                                                    @Nullable
                                                                    @Nullable org.moe.natj.general.ptr.Ptr<NSError> error)
        Call this method on your CIImageProcessorKernel subclass to create a new CIImage of the specified extent. The inputs and arguments will be retained so that your subclass can be called when the image is drawn. Arguments is a dictionary containing immutable objects of type NSData, NSString, NSNumber, CIVector or CIColor. This method will return [CIImage emptyImage] if extent is empty. This method will return nil and an error if: * calling outputFormat on your subclass returns an unsupported format * calling formatForInputAtIndex: on your subclass returns an unsupported format * your subclass does not implement processWithInputs:arguments:output:error:

      • automaticallyNotifiesObserversForKey

        public static boolean automaticallyNotifiesObserversForKey​(@NotNull
                                                           @NotNull java.lang.String key)

      • cancelPreviousPerformRequestsWithTarget

        public static void cancelPreviousPerformRequestsWithTarget​(@NotNull
                                                           @NotNull java.lang.Object aTarget)

      • cancelPreviousPerformRequestsWithTargetSelectorObject

        public static void cancelPreviousPerformRequestsWithTargetSelectorObject​(@NotNull
                                                                         @NotNull java.lang.Object aTarget,
                                                                         @NotNull
                                                                         @NotNull org.moe.natj.objc.SEL aSelector,
                                                                         @Nullable
                                                                         @Nullable java.lang.Object anArgument)

      • classFallbacksForKeyedArchiver

        @NotNull
public static @NotNull NSArray<java.lang.String> classFallbacksForKeyedArchiver()

      • classForKeyedUnarchiver

        @NotNull
public static @NotNull org.moe.natj.objc.Class classForKeyedUnarchiver()

      • debugDescription_static

        public static java.lang.String debugDescription_static()

      • description_static

        public static java.lang.String description_static()

      • formatForInputAtIndex

        public static int formatForInputAtIndex​(int input)
        Override this class method if you want your any of the inputs to be in a specific supported CIPixelFormat. The format must be one of kCIFormatBGRA8, kCIFormatRGBAh, kCIFormatRGBAf or kCIFormatR8. On iOS 12 and macOS 10.14, the formats kCIFormatRh and kCIFormatRf are also supported. If the requested inputFormat is 0, then the input will be a supported format that best matches the rendering context's workingFormat. If a processor wants data in a colorspace other than the context workingspace, then call imageByColorMatchingWorkingSpaceToColorSpace on the processor input. If a processor wants it input as alpha-unpremultiplied RGBA data, then call imageByUnpremultiplyingAlpha on the processor input.

      • hash_static

        public static long hash_static()

      • instanceMethodSignatureForSelector

        public static NSMethodSignature instanceMethodSignatureForSelector​(org.moe.natj.objc.SEL aSelector)

      • instancesRespondToSelector

        public static boolean instancesRespondToSelector​(org.moe.natj.objc.SEL aSelector)

      • isSubclassOfClass

        public static boolean isSubclassOfClass​(org.moe.natj.objc.Class aClass)

      • keyPathsForValuesAffectingValueForKey

        @NotNull
public static @NotNull NSSet<java.lang.String> keyPathsForValuesAffectingValueForKey​(@NotNull
                                                                                     @NotNull java.lang.String key)

      • outputFormat

        public static int outputFormat()

      • processWithInputsArgumentsOutputError

        public static boolean processWithInputsArgumentsOutputError​(@Nullable
                                                            @Nullable NSArray<?> inputs,
                                                            @Nullable
                                                            @Nullable NSDictionary<java.lang.String,​?> arguments,
                                                            @NotNull
                                                            @NotNull CIImageProcessorOutput output,
                                                            @Nullable
                                                            @Nullable org.moe.natj.general.ptr.Ptr<NSError> error)
        Override this class method to implement your processor's subclass of CIImageProcessorKernel. The class method will be called to produce the requested region of the output image given the required regions of the input images and other arguments. The class method is passed two objects: 'inputs’ An array of id that the block consumes to produces output. The input.region may be larger than the rect returned by 'roiForInputAtIndex'. 'output' The id that the block must provide results to. ‘arguments’ The arguments dictionary passed to applyWithExtent:inputs:arguments:error: The contents of these objects are not valid outside the scope of this method. Note that since this is a class method you cannot use or capture any state by accident. All the parameters that affect the output results must be passed in ‘inputs’ and ‘arguments'. This supports 0, 1, 2 or more input images.

      • resolveClassMethod

        public static boolean resolveClassMethod​(org.moe.natj.objc.SEL sel)

      • resolveInstanceMethod

        public static boolean resolveInstanceMethod​(org.moe.natj.objc.SEL sel)

      • roiForInputArgumentsOutputRect

        public static CGRect roiForInputArgumentsOutputRect​(int input,
                                                    @Nullable
                                                    @Nullable NSDictionary<java.lang.String,​?> arguments,
                                                    CGRect outputRect)
        Override this class method to implement your processor’s ROI callback, the default implementation would return outputRect. This will be called one or more times per render to determine what portion of the input images are needed to render a given 'outputRect' of the output. This will not be called if there are 0 input images. Note that since this is a class method you cannot use or capture any state by accident. All the parameters that affect the output results must be passed in ‘inputs’ and ‘arguments’.

      • setVersion_static

        public static void setVersion_static​(long aVersion)

      • superclass_static

        public static org.moe.natj.objc.Class superclass_static()

      • synchronizeInputs

        public static boolean synchronizeInputs()

      • version_static

        public static long version_static()

      • outputIsOpaque

        public static boolean outputIsOpaque()
        API-Since: 11.0

      • roiTileArrayForInputArgumentsOutputRect

        @NotNull
public static @NotNull NSArray<? extends CIVector> roiTileArrayForInputArgumentsOutputRect​(int input,
                                                                                           @Nullable
                                                                                           @Nullable NSDictionary<java.lang.String,​?> arguments,
                                                                                           CGRect outputRect)
        Returns an array of CIVectors that specify tile regions for 'input' that are needed to satisfy 'outputRect'. Each region tile in the array is a created by calling [CIVector vectorWithCGRect:roi] The tiles may overlap but should fully cover the area of 'input' that is needed. If a processor has multiple inputs, then each input should return the same number of region tiles. If the processor implements this method, then when rendered; - as CoreImage prepares for a render, this method will be called for each input to return the roiArray. - as CoreImage performs the render, the method 'processWithInputs:arguments:output:' will be called once for for each tile. API-Since: 17.0

      • useStoredAccessor

        @Deprecated
public static boolean useStoredAccessor()
        Deprecated.