Favivon - Correção

node_modules/@monogrid/gainmap-js/dist/decode/shared/Loader.d.ts

@@ -0,0 +1,59 @@
+import { HalfFloatType, LinearSRGBColorSpace, Loader, LoadingManager, Texture } from 'three';
+import { type GainMapMetadata, QuadRendererTextureOptions } from '../../core/types';
+import { DecodeParameters } from './types';
+/**
+ * Configuration for the loader base class
+ */
+export interface LoaderBaseConfig<TRenderer, TQuadRenderer, TMaterial> {
+    renderer?: TRenderer;
+    renderTargetOptions?: QuadRendererTextureOptions;
+    createMaterial: (params: DecodeParameters) => TMaterial;
+    createQuadRenderer: (params: {
+        width: number;
+        height: number;
+        type: typeof HalfFloatType;
+        colorSpace: typeof LinearSRGBColorSpace;
+        material: TMaterial;
+        renderer?: TRenderer;
+        renderTargetOptions?: QuadRendererTextureOptions;
+    }) => TQuadRenderer;
+}
+/**
+ * Shared base class for loaders that extracts common logic
+ */
+export declare abstract class LoaderBaseShared<TRenderer, TQuadRenderer, TMaterial, TUrl = string> extends Loader<TQuadRenderer, TUrl> {
+    private _renderer?;
+    private _renderTargetOptions?;
+    protected _internalLoadingManager: LoadingManager;
+    protected _config: LoaderBaseConfig<TRenderer, TQuadRenderer, TMaterial>;
+    constructor(config: LoaderBaseConfig<TRenderer, TQuadRenderer, TMaterial>, manager?: LoadingManager);
+    setRenderer(renderer: TRenderer): this;
+    setRenderTargetOptions(options: QuadRendererTextureOptions): this;
+    protected prepareQuadRenderer(): TQuadRenderer;
+    protected processImages(sdrBuffer: ArrayBuffer, gainMapBuffer?: ArrayBuffer, imageOrientation?: 'flipY' | 'from-image'): Promise<{
+        sdrImage: ImageBitmap | HTMLImageElement;
+        gainMapImage: ImageBitmap | HTMLImageElement | undefined;
+        needsFlip: boolean;
+    }>;
+    protected createTextures(sdrImage: ImageBitmap | HTMLImageElement, gainMapImage: ImageBitmap | HTMLImageElement | undefined, needsFlip: boolean): {
+        gainMap: Texture;
+        sdr: Texture;
+    };
+    protected updateQuadRenderer(quadRenderer: TQuadRenderer & {
+        width: number;
+        height: number;
+        material: TMaterial & {
+            gainMap: Texture;
+            sdr: Texture;
+            gainMapMin: [number, number, number];
+            gainMapMax: [number, number, number];
+            offsetHdr: [number, number, number];
+            offsetSdr: [number, number, number];
+            gamma: [number, number, number];
+            hdrCapacityMin: number;
+            hdrCapacityMax: number;
+            maxDisplayBoost: number;
+            needsUpdate: boolean;
+        };
+    }, sdrImage: ImageBitmap | HTMLImageElement, gainMap: Texture, sdr: Texture, metadata: GainMapMetadata): void;
+}

node_modules/@monogrid/gainmap-js/dist/decode/shared/decode.d.ts

@@ -0,0 +1,24 @@
+import { HalfFloatType, LinearSRGBColorSpace } from 'three';
+import { Constructor, QuadRendererTextureOptions } from '../../core';
+import { DecodeParametersWithRenderer } from './types';
+/**
+ * Configuration for decode function
+ */
+export interface DecodeConfig<TRenderer extends Constructor, TQuadRenderer, TMaterial> {
+    renderer: TRenderer;
+    createMaterial: (params: DecodeParametersWithRenderer<InstanceType<TRenderer>>) => TMaterial;
+    createQuadRenderer: (params: {
+        width: number;
+        height: number;
+        type: typeof HalfFloatType;
+        colorSpace: typeof LinearSRGBColorSpace;
+        material: TMaterial;
+        renderer: InstanceType<TRenderer>;
+        renderTargetOptions?: QuadRendererTextureOptions;
+    }) => TQuadRenderer;
+}
+/**
+ * Shared decode implementation factory
+ * Creates a decode function that prepares a QuadRenderer with the given parameters
+ */
+export declare function createDecodeFunction<TRenderer extends Constructor, TQuadRenderer, TMaterial>(config: DecodeConfig<TRenderer, TQuadRenderer, TMaterial>): (params: DecodeParametersWithRenderer<InstanceType<TRenderer>>) => TQuadRenderer;

node_modules/@monogrid/gainmap-js/dist/decode/shared/errors/GainMapNotFoundError.d.ts

@@ -0,0 +1,2 @@
+export declare class GainMapNotFoundError extends Error {
+}

node_modules/@monogrid/gainmap-js/dist/decode/shared/errors/XMPMetadataNotFoundError.d.ts

@@ -0,0 +1,2 @@
+export declare class XMPMetadataNotFoundError extends Error {
+}

node_modules/@monogrid/gainmap-js/dist/decode/shared/extract.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Extracts XMP Metadata and the gain map recovery image
+ * from a single JPEG file.
+ *
+ * @category Decoding Functions
+ * @group Decoding Functions
+ * @param jpegFile an `Uint8Array` containing and encoded JPEG file
+ * @returns an sdr `Uint8Array` compressed in JPEG, a gainMap `Uint8Array` compressed in JPEG and the XMP parsed XMP metadata
+ * @throws Error if XMP Metadata is not found
+ * @throws Error if Gain map image is not found
+ * @example
+ * import { FileLoader } from 'three'
+ * import { extractGainmapFromJPEG } from '@monogrid/gainmap-js'
+ *
+ * const jpegFile = await new FileLoader()
+ *  .setResponseType('arraybuffer')
+ *  .loadAsync('image.jpg')
+ *
+ * const { sdr, gainMap, metadata } = extractGainmapFromJPEG(jpegFile)
+ */
+export declare const extractGainmapFromJPEG: (jpegFile: Uint8Array<ArrayBuffer>) => Promise<{
+    sdr: Uint8Array<ArrayBuffer>;
+    gainMap: Uint8Array<ArrayBuffer>;
+    metadata: import("..").GainMapMetadata;
+}>;

node_modules/@monogrid/gainmap-js/dist/decode/shared/index.d.ts

@@ -0,0 +1,8 @@
+export * from './decode';
+export * from './errors/GainMapNotFoundError';
+export * from './errors/XMPMetadataNotFoundError';
+export * from './extract';
+export * from './Loader';
+export * from './types';
+export * from './utils/extractXMP';
+export * from './utils/MPFExtractor';

node_modules/@monogrid/gainmap-js/dist/decode/shared/types.d.ts

@@ -0,0 +1,43 @@
+import { Texture } from 'three';
+import { GainMapMetadata, QuadRendererTextureOptions, TextureImageFormat } from '../../core';
+/**
+ * Parameters related to the display used for decoding
+ */
+export type GainmapDecodingParameters = {
+    /**
+     * The maximum available boost supported by a display, at a given point in time.
+     *
+     * @remarks
+     * This value can change over time based on device settings and other factors,
+     * such as ambient light conditions, or how many bright pixels are on the screen.
+     *
+     * Non Logarithmic space
+     */
+    maxDisplayBoost: number;
+};
+/**
+ * Parameters for generic decoding
+ */
+export type DecodeParameters = {
+    /**
+     * A Texture containing the SDR Rendition
+     */
+    sdr: Texture<TextureImageFormat>;
+    /**
+     * A Texture containing the GainMap recovery image
+     */
+    gainMap: Texture<TextureImageFormat>;
+} & GainmapDecodingParameters & GainMapMetadata;
+/**
+ * Parameters for decode function
+ */
+export type DecodeParametersWithRenderer<TRenderer> = {
+    /**
+     * The renderer used to decode the GainMap
+     */
+    renderer: TRenderer;
+    /**
+     * Options to use when creating the output renderTarget
+     */
+    renderTargetOptions?: QuadRendererTextureOptions;
+} & DecodeParameters & GainmapDecodingParameters & GainMapMetadata;

node_modules/@monogrid/gainmap-js/dist/decode/shared/utils/MPFExtractor.d.ts

@@ -0,0 +1,21 @@
+export type MPFExtractorOptions = {
+    debug: boolean;
+    extractFII: boolean;
+    extractNonFII: boolean;
+};
+/**
+ * MPF Extractor (Multi Picture Format Extractor)
+ * By Henrik S Nilsson 2019
+ *
+ * Extracts images stored in images based on the MPF format (found here: https://www.cipa.jp/e/std/std-sec.html
+ * under "CIPA DC-007-Translation-2021 Multi-Picture Format"
+ *
+ * Overly commented, and without intention of being complete or production ready.
+ * Created to extract depth maps from iPhone images, and to learn about image metadata.
+ * Kudos to: Phil Harvey (exiftool), Jaume Sanchez (android-lens-blur-depth-extractor)
+ */
+export declare class MPFExtractor {
+    options: MPFExtractorOptions;
+    constructor(options?: Partial<MPFExtractorOptions>);
+    extract(imageArrayBuffer: Uint8Array<ArrayBuffer>): Promise<Blob[]>;
+}

node_modules/@monogrid/gainmap-js/dist/decode/shared/utils/extractXMP.d.ts

@@ -0,0 +1,2 @@
+import { GainMapMetadata } from '../../../core/types';
+export declare const extractXMP: (input: Uint8Array) => GainMapMetadata | undefined;

node_modules/@monogrid/gainmap-js/dist/decode/shared/utils/get-html-image-from-blob.d.ts

@@ -0,0 +1,7 @@
+/**
+ * private function, async get image from blob
+ *
+ * @param blob
+ * @returns
+ */
+export declare const getHTMLImageFromBlob: (blob: Blob) => Promise<HTMLImageElement>;