Buckets:
| import{s as sn,o as an,n as Ht}from"../chunks/scheduler.53228c21.js";import{S as rn,i as ln,e as r,s as i,c as g,q as tn,H as dn,h as cn,a as l,d as t,b as s,f as x,g as h,j as p,r as on,v as pn,k as T,l as n,m as a,n as f,t as _,o as v,p as b}from"../chunks/index.100fac89.js";import{C as un}from"../chunks/CopyLLMTxtMenu.0b55cb5b.js";import{D as q}from"../chunks/Docstring.30334b5e.js";import{C as Gt}from"../chunks/CodeBlock.d30a6509.js";import{E as Et}from"../chunks/ExampleCodeBlock.b9320027.js";import{H as it,E as mn}from"../chunks/MermaidChart.svelte_svelte_type_style_lang.9588cb3a.js";function gn(C){let c,w="Examples:",u,m,M;return m=new Gt({props:{code:"aW1wb3J0JTIwZGlmZnVzZXJzJTBBaW1wb3J0JTIwdG9yY2glMEElMEFwaXBlJTIwJTNEJTIwZGlmZnVzZXJzLk1hcmlnb2xkRGVwdGhQaXBlbGluZS5mcm9tX3ByZXRyYWluZWQoJTBBJTIwJTIwJTIwJTIwJTIycHJzLWV0aCUyRm1hcmlnb2xkLWRlcHRoLXYxLTElMjIlMkMlMjB2YXJpYW50JTNEJTIyZnAxNiUyMiUyQyUyMHRvcmNoX2R0eXBlJTNEdG9yY2guZmxvYXQxNiUwQSkudG8oJTIyY3VkYSUyMiklMEElMEFpbWFnZSUyMCUzRCUyMGRpZmZ1c2Vycy51dGlscy5sb2FkX2ltYWdlKCUyMmh0dHBzJTNBJTJGJTJGbWFyaWdvbGRtb25vZGVwdGguZ2l0aHViLmlvJTJGaW1hZ2VzJTJGZWluc3RlaW4uanBnJTIyKSUwQWRlcHRoJTIwJTNEJTIwcGlwZShpbWFnZSklMEElMEF2aXMlMjAlM0QlMjBwaXBlLmltYWdlX3Byb2Nlc3Nvci52aXN1YWxpemVfZGVwdGgoZGVwdGgucHJlZGljdGlvbiklMEF2aXMlNUIwJTVELnNhdmUoJTIyZWluc3RlaW5fZGVwdGgucG5nJTIyKSUwQSUwQWRlcHRoXzE2Yml0JTIwJTNEJTIwcGlwZS5pbWFnZV9wcm9jZXNzb3IuZXhwb3J0X2RlcHRoX3RvXzE2Yml0X3BuZyhkZXB0aC5wcmVkaWN0aW9uKSUwQWRlcHRoXzE2Yml0JTVCMCU1RC5zYXZlKCUyMmVpbnN0ZWluX2RlcHRoXzE2Yml0LnBuZyUyMik=",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> diffusers | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> torch | |
| <span class="hljs-meta">>>> </span>pipe = diffusers.MarigoldDepthPipeline.from_pretrained( | |
| <span class="hljs-meta">... </span> <span class="hljs-string">"prs-eth/marigold-depth-v1-1"</span>, variant=<span class="hljs-string">"fp16"</span>, torch_dtype=torch.float16 | |
| <span class="hljs-meta">... </span>).to(<span class="hljs-string">"cuda"</span>) | |
| <span class="hljs-meta">>>> </span>image = diffusers.utils.load_image(<span class="hljs-string">"https://marigoldmonodepth.github.io/images/einstein.jpg"</span>) | |
| <span class="hljs-meta">>>> </span>depth = pipe(image) | |
| <span class="hljs-meta">>>> </span>vis = pipe.image_processor.visualize_depth(depth.prediction) | |
| <span class="hljs-meta">>>> </span>vis[<span class="hljs-number">0</span>].save(<span class="hljs-string">"einstein_depth.png"</span>) | |
| <span class="hljs-meta">>>> </span>depth_16bit = pipe.image_processor.export_depth_to_16bit_png(depth.prediction) | |
| <span class="hljs-meta">>>> </span>depth_16bit[<span class="hljs-number">0</span>].save(<span class="hljs-string">"einstein_depth_16bit.png"</span>)`,wrap:!1}}),{c(){c=r("p"),c.textContent=w,u=i(),g(m.$$.fragment)},l(d){c=l(d,"P",{"data-svelte-h":!0}),p(c)!=="svelte-kvfsh7"&&(c.textContent=w),u=s(d),h(m.$$.fragment,d)},m(d,y){a(d,c,y),a(d,u,y),f(m,d,y),M=!0},p:Ht,i(d){M||(_(m.$$.fragment,d),M=!0)},o(d){v(m.$$.fragment,d),M=!1},d(d){d&&(t(c),t(u)),b(m,d)}}}function hn(C){let c,w="Examples:",u,m,M;return m=new Gt({props:{code:"aW1wb3J0JTIwZGlmZnVzZXJzJTBBaW1wb3J0JTIwdG9yY2glMEElMEFwaXBlJTIwJTNEJTIwZGlmZnVzZXJzLk1hcmlnb2xkTm9ybWFsc1BpcGVsaW5lLmZyb21fcHJldHJhaW5lZCglMEElMjAlMjAlMjAlMjAlMjJwcnMtZXRoJTJGbWFyaWdvbGQtbm9ybWFscy12MS0xJTIyJTJDJTIwdmFyaWFudCUzRCUyMmZwMTYlMjIlMkMlMjB0b3JjaF9kdHlwZSUzRHRvcmNoLmZsb2F0MTYlMEEpLnRvKCUyMmN1ZGElMjIpJTBBJTBBaW1hZ2UlMjAlM0QlMjBkaWZmdXNlcnMudXRpbHMubG9hZF9pbWFnZSglMjJodHRwcyUzQSUyRiUyRm1hcmlnb2xkbW9ub2RlcHRoLmdpdGh1Yi5pbyUyRmltYWdlcyUyRmVpbnN0ZWluLmpwZyUyMiklMEFub3JtYWxzJTIwJTNEJTIwcGlwZShpbWFnZSklMEElMEF2aXMlMjAlM0QlMjBwaXBlLmltYWdlX3Byb2Nlc3Nvci52aXN1YWxpemVfbm9ybWFscyhub3JtYWxzLnByZWRpY3Rpb24pJTBBdmlzJTVCMCU1RC5zYXZlKCUyMmVpbnN0ZWluX25vcm1hbHMucG5nJTIyKQ==",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> diffusers | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> torch | |
| <span class="hljs-meta">>>> </span>pipe = diffusers.MarigoldNormalsPipeline.from_pretrained( | |
| <span class="hljs-meta">... </span> <span class="hljs-string">"prs-eth/marigold-normals-v1-1"</span>, variant=<span class="hljs-string">"fp16"</span>, torch_dtype=torch.float16 | |
| <span class="hljs-meta">... </span>).to(<span class="hljs-string">"cuda"</span>) | |
| <span class="hljs-meta">>>> </span>image = diffusers.utils.load_image(<span class="hljs-string">"https://marigoldmonodepth.github.io/images/einstein.jpg"</span>) | |
| <span class="hljs-meta">>>> </span>normals = pipe(image) | |
| <span class="hljs-meta">>>> </span>vis = pipe.image_processor.visualize_normals(normals.prediction) | |
| <span class="hljs-meta">>>> </span>vis[<span class="hljs-number">0</span>].save(<span class="hljs-string">"einstein_normals.png"</span>)`,wrap:!1}}),{c(){c=r("p"),c.textContent=w,u=i(),g(m.$$.fragment)},l(d){c=l(d,"P",{"data-svelte-h":!0}),p(c)!=="svelte-kvfsh7"&&(c.textContent=w),u=s(d),h(m.$$.fragment,d)},m(d,y){a(d,c,y),a(d,u,y),f(m,d,y),M=!0},p:Ht,i(d){M||(_(m.$$.fragment,d),M=!0)},o(d){v(m.$$.fragment,d),M=!1},d(d){d&&(t(c),t(u)),b(m,d)}}}function fn(C){let c,w="Examples:",u,m,M;return m=new Gt({props:{code:"aW1wb3J0JTIwZGlmZnVzZXJzJTBBaW1wb3J0JTIwdG9yY2glMEElMEFwaXBlJTIwJTNEJTIwZGlmZnVzZXJzLk1hcmlnb2xkSW50cmluc2ljc1BpcGVsaW5lLmZyb21fcHJldHJhaW5lZCglMEElMjAlMjAlMjAlMjAlMjJwcnMtZXRoJTJGbWFyaWdvbGQtaWlkLWFwcGVhcmFuY2UtdjEtMSUyMiUyQyUyMHZhcmlhbnQlM0QlMjJmcDE2JTIyJTJDJTIwdG9yY2hfZHR5cGUlM0R0b3JjaC5mbG9hdDE2JTBBKS50byglMjJjdWRhJTIyKSUwQSUwQWltYWdlJTIwJTNEJTIwZGlmZnVzZXJzLnV0aWxzLmxvYWRfaW1hZ2UoJTIyaHR0cHMlM0ElMkYlMkZtYXJpZ29sZG1vbm9kZXB0aC5naXRodWIuaW8lMkZpbWFnZXMlMkZlaW5zdGVpbi5qcGclMjIpJTBBaW50cmluc2ljcyUyMCUzRCUyMHBpcGUoaW1hZ2UpJTBBJTBBdmlzJTIwJTNEJTIwcGlwZS5pbWFnZV9wcm9jZXNzb3IudmlzdWFsaXplX2ludHJpbnNpY3MoaW50cmluc2ljcy5wcmVkaWN0aW9uJTJDJTIwcGlwZS50YXJnZXRfcHJvcGVydGllcyklMEF2aXMlNUIwJTVEJTVCJTIyYWxiZWRvJTIyJTVELnNhdmUoJTIyZWluc3RlaW5fYWxiZWRvLnBuZyUyMiklMEF2aXMlNUIwJTVEJTVCJTIycm91Z2huZXNzJTIyJTVELnNhdmUoJTIyZWluc3RlaW5fcm91Z2huZXNzLnBuZyUyMiklMEF2aXMlNUIwJTVEJTVCJTIybWV0YWxsaWNpdHklMjIlNUQuc2F2ZSglMjJlaW5zdGVpbl9tZXRhbGxpY2l0eS5wbmclMjIp",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> diffusers | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> torch | |
| <span class="hljs-meta">>>> </span>pipe = diffusers.MarigoldIntrinsicsPipeline.from_pretrained( | |
| <span class="hljs-meta">... </span> <span class="hljs-string">"prs-eth/marigold-iid-appearance-v1-1"</span>, variant=<span class="hljs-string">"fp16"</span>, torch_dtype=torch.float16 | |
| <span class="hljs-meta">... </span>).to(<span class="hljs-string">"cuda"</span>) | |
| <span class="hljs-meta">>>> </span>image = diffusers.utils.load_image(<span class="hljs-string">"https://marigoldmonodepth.github.io/images/einstein.jpg"</span>) | |
| <span class="hljs-meta">>>> </span>intrinsics = pipe(image) | |
| <span class="hljs-meta">>>> </span>vis = pipe.image_processor.visualize_intrinsics(intrinsics.prediction, pipe.target_properties) | |
| <span class="hljs-meta">>>> </span>vis[<span class="hljs-number">0</span>][<span class="hljs-string">"albedo"</span>].save(<span class="hljs-string">"einstein_albedo.png"</span>) | |
| <span class="hljs-meta">>>> </span>vis[<span class="hljs-number">0</span>][<span class="hljs-string">"roughness"</span>].save(<span class="hljs-string">"einstein_roughness.png"</span>) | |
| <span class="hljs-meta">>>> </span>vis[<span class="hljs-number">0</span>][<span class="hljs-string">"metallicity"</span>].save(<span class="hljs-string">"einstein_metallicity.png"</span>)`,wrap:!1}}),{c(){c=r("p"),c.textContent=w,u=i(),g(m.$$.fragment)},l(d){c=l(d,"P",{"data-svelte-h":!0}),p(c)!=="svelte-kvfsh7"&&(c.textContent=w),u=s(d),h(m.$$.fragment,d)},m(d,y){a(d,c,y),a(d,u,y),f(m,d,y),M=!0},p:Ht,i(d){M||(_(m.$$.fragment,d),M=!0)},o(d){v(m.$$.fragment,d),M=!1},d(d){d&&(t(c),t(u)),b(m,d)}}}function _n(C){let c,w;return c=new Gt({props:{code:"aW1wb3J0JTIwZGlmZnVzZXJzJTBBaW1wb3J0JTIwdG9yY2glMEElMEFwaXBlJTIwJTNEJTIwZGlmZnVzZXJzLk1hcmlnb2xkSW50cmluc2ljc1BpcGVsaW5lLmZyb21fcHJldHJhaW5lZCglMEElMjAlMjAlMjAlMjAlMjJwcnMtZXRoJTJGbWFyaWdvbGQtaWlkLWxpZ2h0aW5nLXYxLTElMjIlMkMlMjB2YXJpYW50JTNEJTIyZnAxNiUyMiUyQyUyMHRvcmNoX2R0eXBlJTNEdG9yY2guZmxvYXQxNiUwQSkudG8oJTIyY3VkYSUyMiklMEElMEFpbWFnZSUyMCUzRCUyMGRpZmZ1c2Vycy51dGlscy5sb2FkX2ltYWdlKCUyMmh0dHBzJTNBJTJGJTJGbWFyaWdvbGRtb25vZGVwdGguZ2l0aHViLmlvJTJGaW1hZ2VzJTJGZWluc3RlaW4uanBnJTIyKSUwQWludHJpbnNpY3MlMjAlM0QlMjBwaXBlKGltYWdlKSUwQSUwQXZpcyUyMCUzRCUyMHBpcGUuaW1hZ2VfcHJvY2Vzc29yLnZpc3VhbGl6ZV9pbnRyaW5zaWNzKGludHJpbnNpY3MucHJlZGljdGlvbiUyQyUyMHBpcGUudGFyZ2V0X3Byb3BlcnRpZXMpJTBBdmlzJTVCMCU1RCU1QiUyMmFsYmVkbyUyMiU1RC5zYXZlKCUyMmVpbnN0ZWluX2FsYmVkby5wbmclMjIpJTBBdmlzJTVCMCU1RCU1QiUyMnNoYWRpbmclMjIlNUQuc2F2ZSglMjJlaW5zdGVpbl9zaGFkaW5nLnBuZyUyMiklMEF2aXMlNUIwJTVEJTVCJTIycmVzaWR1YWwlMjIlNUQuc2F2ZSglMjJlaW5zdGVpbl9yZXNpZHVhbC5wbmclMjIp",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> diffusers | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> torch | |
| <span class="hljs-meta">>>> </span>pipe = diffusers.MarigoldIntrinsicsPipeline.from_pretrained( | |
| <span class="hljs-meta">... </span> <span class="hljs-string">"prs-eth/marigold-iid-lighting-v1-1"</span>, variant=<span class="hljs-string">"fp16"</span>, torch_dtype=torch.float16 | |
| <span class="hljs-meta">... </span>).to(<span class="hljs-string">"cuda"</span>) | |
| <span class="hljs-meta">>>> </span>image = diffusers.utils.load_image(<span class="hljs-string">"https://marigoldmonodepth.github.io/images/einstein.jpg"</span>) | |
| <span class="hljs-meta">>>> </span>intrinsics = pipe(image) | |
| <span class="hljs-meta">>>> </span>vis = pipe.image_processor.visualize_intrinsics(intrinsics.prediction, pipe.target_properties) | |
| <span class="hljs-meta">>>> </span>vis[<span class="hljs-number">0</span>][<span class="hljs-string">"albedo"</span>].save(<span class="hljs-string">"einstein_albedo.png"</span>) | |
| <span class="hljs-meta">>>> </span>vis[<span class="hljs-number">0</span>][<span class="hljs-string">"shading"</span>].save(<span class="hljs-string">"einstein_shading.png"</span>) | |
| <span class="hljs-meta">>>> </span>vis[<span class="hljs-number">0</span>][<span class="hljs-string">"residual"</span>].save(<span class="hljs-string">"einstein_residual.png"</span>)`,wrap:!1}}),{c(){g(c.$$.fragment)},l(u){h(c.$$.fragment,u)},m(u,m){f(c,u,m),w=!0},p:Ht,i(u){w||(_(c.$$.fragment,u),w=!0)},o(u){v(c.$$.fragment,u),w=!1},d(u){b(c,u)}}}function vn(C){let c,w,u,m,M,d,y,at,te,yo='<img src="https://marigoldmonodepth.github.io/images/teaser_collage_compressed.jpg" alt="marigold"/>',rt,oe,wo=`Marigold was proposed in | |
| <a href="https://huggingface.co/papers/2312.02145" rel="nofollow">Repurposing Diffusion-Based Image Generators for Monocular Depth Estimation</a>, | |
| a CVPR 2024 Oral paper by | |
| <a href="http://www.kebingxin.com/" rel="nofollow">Bingxin Ke</a>, | |
| <a href="https://www.obukhov.ai/" rel="nofollow">Anton Obukhov</a>, | |
| <a href="https://shengyuh.github.io/" rel="nofollow">Shengyu Huang</a>, | |
| <a href="https://nandometzger.github.io/" rel="nofollow">Nando Metzger</a>, | |
| <a href="https://rcdaudt.github.io/" rel="nofollow">Rodrigo Caye Daudt</a>, and | |
| <a href="https://scholar.google.com/citations?user=FZuNgqIAAAAJ&hl=en" rel="nofollow">Konrad Schindler</a>. | |
| The core idea is to <strong>repurpose the generative prior of Text-to-Image Latent Diffusion Models (LDMs) for traditional | |
| computer vision tasks</strong>. | |
| This approach was explored by fine-tuning Stable Diffusion for <strong>Monocular Depth Estimation</strong>, as demonstrated in the | |
| teaser above.`,lt,ne,xo=`Marigold was later extended in the follow-up paper, | |
| <a href="https://huggingface.co/papers/2312.02145" rel="nofollow">Marigold: Affordable Adaptation of Diffusion-Based Image Generators for Image Analysis</a>, | |
| authored by | |
| <a href="http://www.kebingxin.com/" rel="nofollow">Bingxin Ke</a>, | |
| <a href="https://www.linkedin.com/in/kevin-qu-b3417621b/?locale=en_US" rel="nofollow">Kevin Qu</a>, | |
| <a href="https://tianfwang.github.io/" rel="nofollow">Tianfu Wang</a>, | |
| <a href="https://nandometzger.github.io/" rel="nofollow">Nando Metzger</a>, | |
| <a href="https://shengyuh.github.io/" rel="nofollow">Shengyu Huang</a>, | |
| <a href="https://www.linkedin.com/in/bobboli0202/" rel="nofollow">Bo Li</a>, | |
| <a href="https://www.obukhov.ai/" rel="nofollow">Anton Obukhov</a>, and | |
| <a href="https://scholar.google.com/citations?user=FZuNgqIAAAAJ&hl=en" rel="nofollow">Konrad Schindler</a>. | |
| This work expanded Marigold to support new modalities such as <strong>Surface Normals</strong> and <strong>Intrinsic Image Decomposition</strong> | |
| (IID), introduced a training protocol for <strong>Latent Consistency Models</strong> (LCM), and demonstrated <strong>High-Resolution</strong> (HR) | |
| processing capability.`,dt,U,To=`<p>The early Marigold models (<code>v1-0</code> and earlier) were optimized for best results with at least 10 inference steps. | |
| LCM models were later developed to enable high-quality inference in just 1 to 4 steps. | |
| Marigold models <code>v1-1</code> and later use the DDIM scheduler to achieve optimal | |
| results in as few as 1 to 4 steps.</p>`,ct,ie,pt,se,Io=`Each pipeline is tailored for a specific computer vision task, processing an input RGB image and generating a | |
| corresponding prediction. | |
| Currently, the following computer vision tasks are implemented:`,ut,ae,$o='<thead><tr><th>Pipeline</th> <th>Recommended Model Checkpoints</th> <th align="center">Spaces (Interactive Apps)</th> <th>Predicted Modalities</th></tr></thead> <tbody><tr><td><a href="https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_depth.py" rel="nofollow">MarigoldDepthPipeline</a></td> <td><a href="https://huggingface.co/prs-eth/marigold-depth-v1-1" rel="nofollow">prs-eth/marigold-depth-v1-1</a></td> <td align="center"><a href="https://huggingface.co/spaces/prs-eth/marigold" rel="nofollow">Depth Estimation</a></td> <td><a href="https://en.wikipedia.org/wiki/Depth_map" rel="nofollow">Depth</a>, <a href="https://en.wikipedia.org/wiki/Binocular_disparity" rel="nofollow">Disparity</a></td></tr> <tr><td><a href="https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_normals.py" rel="nofollow">MarigoldNormalsPipeline</a></td> <td><a href="https://huggingface.co/prs-eth/marigold-normals-v1-1" rel="nofollow">prs-eth/marigold-normals-v1-1</a></td> <td align="center"><a href="https://huggingface.co/spaces/prs-eth/marigold-normals" rel="nofollow">Surface Normals Estimation</a></td> <td><a href="https://en.wikipedia.org/wiki/Normal_mapping" rel="nofollow">Surface normals</a></td></tr> <tr><td><a href="https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_intrinsics.py" rel="nofollow">MarigoldIntrinsicsPipeline</a></td> <td><a href="https://huggingface.co/prs-eth/marigold-iid-appearance-v1-1" rel="nofollow">prs-eth/marigold-iid-appearance-v1-1</a>,<br/><a href="https://huggingface.co/prs-eth/marigold-iid-lighting-v1-1" rel="nofollow">prs-eth/marigold-iid-lighting-v1-1</a></td> <td align="center"><a href="https://huggingface.co/spaces/prs-eth/marigold-iid" rel="nofollow">Intrinsic Image Decomposition</a></td> <td><a href="https://en.wikipedia.org/wiki/Albedo" rel="nofollow">Albedo</a>, <a href="https://www.n.aiq3d.com/wiki/roughnessmetalnessao-map" rel="nofollow">Materials</a>, <a href="https://en.wikipedia.org/wiki/Diffuse_reflection" rel="nofollow">Lighting</a></td></tr></tbody>',mt,re,gt,le,No=`All original checkpoints are available under the <a href="https://huggingface.co/prs-eth/" rel="nofollow">PRS-ETH</a> organization on Hugging Face. | |
| They are designed for use with diffusers pipelines and the <a href="https://github.com/prs-eth/marigold" rel="nofollow">original codebase</a>, which can also be used to train | |
| new model checkpoints. | |
| The following is a summary of the recommended checkpoints, all of which produce reliable results with 1 to 4 steps.`,ht,V,qe,Po="<tr><th>Checkpoint</th> <th>Modality</th> <th>Comment</th></tr>",Rt,D,De,qo='<td><a href="https://huggingface.co/prs-eth/marigold-depth-v1-1" rel="nofollow">prs-eth/marigold-depth-v1-1</a></td> <td>Depth</td> <td>Affine-invariant depth prediction assigns each pixel a value between 0 (near plane) and 1 (far plane), with both planes determined by the model during inference.</td>',Ut,Je,Do='<td><a href="https://huggingface.co/prs-eth/marigold-normals-v0-1" rel="nofollow">prs-eth/marigold-normals-v0-1</a></td> <td>Normals</td> <td>The surface normals predictions are unit-length 3D vectors in the screen space camera, with values in the range from -1 to 1.</td>',Vt,ze,Jo='<td><a href="https://huggingface.co/prs-eth/marigold-iid-appearance-v1-1" rel="nofollow">prs-eth/marigold-iid-appearance-v1-1</a></td> <td>Intrinsics</td> <td>InteriorVerse decomposition is comprised of Albedo and two BRDF material properties: Roughness and Metallicity.</td>',Bt,Z,ke,zo='<a href="https://huggingface.co/prs-eth/marigold-iid-lighting-v1-1" rel="nofollow">prs-eth/marigold-iid-lighting-v1-1</a>',At,Le,ko="Intrinsics",St,de,Xt,ft,nn='<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>I</mi></mrow><annotation encoding="application/x-tex">I</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.07847em;">I</span></span></span></span>',_t,vt,B,Lo=`<p>Make sure to check out the Schedulers <a href="../../using-diffusers/schedulers">guide</a> to learn how to explore the tradeoff | |
| between scheduler speed and quality, and see the <a href="../../using-diffusers/loading#reuse-a-pipeline">reuse components across pipelines</a> section to learn how to | |
| efficiently load the same components into multiple pipelines. | |
| Also, to know more about reducing the memory usage of this pipeline, refer to the [“Reduce memory usage”] section | |
| <a href="../../using-diffusers/svd#reduce-memory-usage">here</a>.</p>`,bt,A,Co=`<p>Marigold pipelines were designed and tested with the scheduler embedded in the model checkpoint. | |
| The optimal number of inference steps varies by scheduler, with no universal value that works best across all cases. | |
| To accommodate this, the <code>num_inference_steps</code> parameter in the pipeline’s <code>__call__</code> method defaults to <code>None</code> (see the | |
| API reference). | |
| Unless set explicitly, it inherits the value from the <code>default_denoising_steps</code> field in the checkpoint configuration | |
| file (<code>model_index.json</code>). | |
| This ensures high-quality predictions when invoking the pipeline with only the <code>image</code> argument.</p>`,Mt,ce,jo='See also Marigold <a href="../../using-diffusers/marigold_usage">usage examples</a>.',yt,pe,wt,I,ue,Ft,Ce,Wo='Pipeline for monocular depth estimation using the Marigold method: <a href="https://marigoldmonodepth.github.io" rel="nofollow">https://marigoldmonodepth.github.io</a>.',Yt,je,Zo=`This model inherits from <a href="/docs/diffusers/v0.37.1/en/api/pipelines/overview#diffusers.DiffusionPipeline">DiffusionPipeline</a>. Check the superclass documentation for the generic methods the | |
| library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)`,Ot,j,me,Qt,We,Eo="Function invoked when calling the pipeline.",Kt,S,xt,E,ge,eo,Ze,Ho="Output class for Marigold monocular depth prediction pipeline.",Tt,J,he,to,Ee,Go="Visualizes depth maps, such as predictions of the <code>MarigoldDepthPipeline</code>.",oo,He,Ro="Returns: <code>list[PIL.Image.Image]</code> with depth maps visualization.",It,fe,$t,$,_e,no,Ge,Uo='Pipeline for monocular normals estimation using the Marigold method: <a href="https://marigoldmonodepth.github.io" rel="nofollow">https://marigoldmonodepth.github.io</a>.',io,Re,Vo=`This model inherits from <a href="/docs/diffusers/v0.37.1/en/api/pipelines/overview#diffusers.DiffusionPipeline">DiffusionPipeline</a>. Check the superclass documentation for the generic methods the | |
| library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)`,so,W,ve,ao,Ue,Bo="Function invoked when calling the pipeline.",ro,X,Nt,H,be,lo,Ve,Ao="Output class for Marigold monocular normals prediction pipeline.",Pt,z,Me,co,Be,So="Visualizes surface normals, such as predictions of the <code>MarigoldNormalsPipeline</code>.",po,Ae,Xo="Returns: <code>list[PIL.Image.Image]</code> with surface normals visualization.",qt,ye,Dt,N,we,uo,Se,Fo=`Pipeline for Intrinsic Image Decomposition (IID) using the Marigold method: | |
| <a href="https://marigoldcomputervision.github.io" rel="nofollow">https://marigoldcomputervision.github.io</a>.`,mo,Xe,Yo=`This model inherits from <a href="/docs/diffusers/v0.37.1/en/api/pipelines/overview#diffusers.DiffusionPipeline">DiffusionPipeline</a>. Check the superclass documentation for the generic methods the | |
| library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)`,go,P,xe,ho,Fe,Oo="Function invoked when calling the pipeline.",fo,F,_o,Y,Jt,G,Te,vo,Ye,Qo="Output class for Marigold Intrinsic Image Decomposition pipeline.",zt,k,Ie,bo,Oe,Ko="Visualizes intrinsic image decomposition, such as predictions of the <code>MarigoldIntrinsicsPipeline</code>.",Mo,Qe,en="Returns: <code>list[dict[str, PIL.Image.Image]]</code> with intrinsic image decomposition visualization.",kt,$e,Lt,st,Ct;return M=new un({props:{containerStyle:"float: right; margin-left: 10px; display: inline-flex; position: relative; z-index: 10;"}}),y=new it({props:{title:"Marigold Computer Vision",local:"marigold-computer-vision",headingTag:"h1"}}),ie=new it({props:{title:"Available Pipelines",local:"available-pipelines",headingTag:"h2"}}),re=new it({props:{title:"Available Checkpoints",local:"available-checkpoints",headingTag:"h2"}}),pe=new it({props:{title:"Marigold Depth Prediction API",local:"diffusers.MarigoldDepthPipeline",headingTag:"h2"}}),ue=new q({props:{name:"class diffusers.MarigoldDepthPipeline",anchor:"diffusers.MarigoldDepthPipeline",parameters:[{name:"unet",val:": UNet2DConditionModel"},{name:"vae",val:": AutoencoderKL"},{name:"scheduler",val:": diffusers.schedulers.scheduling_ddim.DDIMScheduler | diffusers.schedulers.scheduling_lcm.LCMScheduler"},{name:"text_encoder",val:": CLIPTextModel"},{name:"tokenizer",val:": CLIPTokenizer"},{name:"prediction_type",val:": str | None = None"},{name:"scale_invariant",val:": bool | None = True"},{name:"shift_invariant",val:": bool | None = True"},{name:"default_denoising_steps",val:": int | None = None"},{name:"default_processing_resolution",val:": int | None = None"}],parametersDescription:[{anchor:"diffusers.MarigoldDepthPipeline.unet",description:`<strong>unet</strong> (<code>UNet2DConditionModel</code>) — | |
| Conditional U-Net to denoise the depth latent, conditioned on image latent.`,name:"unet"},{anchor:"diffusers.MarigoldDepthPipeline.vae",description:`<strong>vae</strong> (<code>AutoencoderKL</code>) — | |
| Variational Auto-Encoder (VAE) Model to encode and decode images and predictions to and from latent | |
| representations.`,name:"vae"},{anchor:"diffusers.MarigoldDepthPipeline.scheduler",description:`<strong>scheduler</strong> (<code>DDIMScheduler</code> or <code>LCMScheduler</code>) — | |
| A scheduler to be used in combination with <code>unet</code> to denoise the encoded image latents.`,name:"scheduler"},{anchor:"diffusers.MarigoldDepthPipeline.text_encoder",description:`<strong>text_encoder</strong> (<code>CLIPTextModel</code>) — | |
| Text-encoder, for empty text embedding.`,name:"text_encoder"},{anchor:"diffusers.MarigoldDepthPipeline.tokenizer",description:`<strong>tokenizer</strong> (<code>CLIPTokenizer</code>) — | |
| CLIP tokenizer.`,name:"tokenizer"},{anchor:"diffusers.MarigoldDepthPipeline.prediction_type",description:`<strong>prediction_type</strong> (<code>str</code>, <em>optional</em>) — | |
| Type of predictions made by the model.`,name:"prediction_type"},{anchor:"diffusers.MarigoldDepthPipeline.scale_invariant",description:`<strong>scale_invariant</strong> (<code>bool</code>, <em>optional</em>) — | |
| A model property specifying whether the predicted depth maps are scale-invariant. This value must be set in | |
| the model config. When used together with the <code>shift_invariant=True</code> flag, the model is also called | |
| “affine-invariant”. NB: overriding this value is not supported.`,name:"scale_invariant"},{anchor:"diffusers.MarigoldDepthPipeline.shift_invariant",description:`<strong>shift_invariant</strong> (<code>bool</code>, <em>optional</em>) — | |
| A model property specifying whether the predicted depth maps are shift-invariant. This value must be set in | |
| the model config. When used together with the <code>scale_invariant=True</code> flag, the model is also called | |
| “affine-invariant”. NB: overriding this value is not supported.`,name:"shift_invariant"},{anchor:"diffusers.MarigoldDepthPipeline.default_denoising_steps",description:`<strong>default_denoising_steps</strong> (<code>int</code>, <em>optional</em>) — | |
| The minimum number of denoising diffusion steps that are required to produce a prediction of reasonable | |
| quality with the given model. This value must be set in the model config. When the pipeline is called | |
| without explicitly setting <code>num_inference_steps</code>, the default value is used. This is required to ensure | |
| reasonable results with various model flavors compatible with the pipeline, such as those relying on very | |
| short denoising schedules (<code>LCMScheduler</code>) and those with full diffusion schedules (<code>DDIMScheduler</code>).`,name:"default_denoising_steps"},{anchor:"diffusers.MarigoldDepthPipeline.default_processing_resolution",description:`<strong>default_processing_resolution</strong> (<code>int</code>, <em>optional</em>) — | |
| The recommended value of the <code>processing_resolution</code> parameter of the pipeline. This value must be set in | |
| the model config. When the pipeline is called without explicitly setting <code>processing_resolution</code>, the | |
| default value is used. This is required to ensure reasonable results with various model flavors trained | |
| with varying optimal processing resolution values.`,name:"default_processing_resolution"}],source:"https://github.com/huggingface/diffusers/blob/v0.37.1/src/diffusers/pipelines/marigold/pipeline_marigold_depth.py#L104"}}),me=new q({props:{name:"__call__",anchor:"diffusers.MarigoldDepthPipeline.__call__",parameters:[{name:"image",val:": PIL.Image.Image | numpy.ndarray | torch.Tensor | list[PIL.Image.Image] | list[numpy.ndarray] | list[torch.Tensor]"},{name:"num_inference_steps",val:": int | None = None"},{name:"ensemble_size",val:": int = 1"},{name:"processing_resolution",val:": int | None = None"},{name:"match_input_resolution",val:": bool = True"},{name:"resample_method_input",val:": str = 'bilinear'"},{name:"resample_method_output",val:": str = 'bilinear'"},{name:"batch_size",val:": int = 1"},{name:"ensembling_kwargs",val:": dict[str, typing.Any] | None = None"},{name:"latents",val:": torch.Tensor | list[torch.Tensor] | None = None"},{name:"generator",val:": torch._C.Generator | list[torch._C.Generator] | None = None"},{name:"output_type",val:": str = 'np'"},{name:"output_uncertainty",val:": bool = False"},{name:"output_latent",val:": bool = False"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.MarigoldDepthPipeline.__call__.image",description:`<strong>image</strong> (<code>PIL.Image.Image</code>, <code>np.ndarray</code>, <code>torch.Tensor</code>, <code>list[PIL.Image.Image]</code>, <code>list[np.ndarray]</code>), — | |
| <code>list[torch.Tensor]</code>: An input image or images used as an input for the depth estimation task. For | |
| arrays and tensors, the expected value range is between <code>[0, 1]</code>. Passing a batch of images is possible | |
| by providing a four-dimensional array or a tensor. Additionally, a list of images of two- or | |
| three-dimensional arrays or tensors can be passed. In the latter case, all list elements must have the | |
| same width and height.`,name:"image"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Number of denoising diffusion steps during inference. The default value <code>None</code> results in automatic | |
| selection.`,name:"num_inference_steps"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.ensemble_size",description:`<strong>ensemble_size</strong> (<code>int</code>, defaults to <code>1</code>) — | |
| Number of ensemble predictions. Higher values result in measurable improvements and visual degradation.`,name:"ensemble_size"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.processing_resolution",description:`<strong>processing_resolution</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Effective processing resolution. When set to <code>0</code>, matches the larger input image dimension. This | |
| produces crisper predictions, but may also lead to the overall loss of global context. The default | |
| value <code>None</code> resolves to the optimal value from the model config.`,name:"processing_resolution"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.match_input_resolution",description:`<strong>match_input_resolution</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| When enabled, the output prediction is resized to match the input dimensions. When disabled, the longer | |
| side of the output will equal to <code>processing_resolution</code>.`,name:"match_input_resolution"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.resample_method_input",description:`<strong>resample_method_input</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"bilinear"</code>) — | |
| Resampling method used to resize input images to <code>processing_resolution</code>. The accepted values are: | |
| <code>"nearest"</code>, <code>"nearest-exact"</code>, <code>"bilinear"</code>, <code>"bicubic"</code>, or <code>"area"</code>.`,name:"resample_method_input"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.resample_method_output",description:`<strong>resample_method_output</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"bilinear"</code>) — | |
| Resampling method used to resize output predictions to match the input resolution. The accepted values | |
| are <code>"nearest"</code>, <code>"nearest-exact"</code>, <code>"bilinear"</code>, <code>"bicubic"</code>, or <code>"area"</code>.`,name:"resample_method_output"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.batch_size",description:`<strong>batch_size</strong> (<code>int</code>, <em>optional</em>, defaults to <code>1</code>) — | |
| Batch size; only matters when setting <code>ensemble_size</code> or passing a tensor of images.`,name:"batch_size"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.ensembling_kwargs",description:`<strong>ensembling_kwargs</strong> (<code>dict</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Extra dictionary with arguments for precise ensembling control. The following options are available: | |
| <ul> | |
| <li>reduction (<code>str</code>, <em>optional</em>, defaults to <code>"median"</code>): Defines the ensembling function applied in | |
| every pixel location, can be either <code>"median"</code> or <code>"mean"</code>.</li> | |
| <li>regularizer_strength (<code>float</code>, <em>optional</em>, defaults to <code>0.02</code>): Strength of the regularizer that | |
| pulls the aligned predictions to the unit range from 0 to 1.</li> | |
| <li>max_iter (<code>int</code>, <em>optional</em>, defaults to <code>2</code>): Maximum number of the alignment solver steps. Refer to | |
| <code>scipy.optimize.minimize</code> function, <code>options</code> argument.</li> | |
| <li>tol (<code>float</code>, <em>optional</em>, defaults to <code>1e-3</code>): Alignment solver tolerance. The solver stops when the | |
| tolerance is reached.</li> | |
| <li>max_res (<code>int</code>, <em>optional</em>, defaults to <code>None</code>): Resolution at which the alignment is performed; | |
| <code>None</code> matches the <code>processing_resolution</code>.</li> | |
| </ul>`,name:"ensembling_kwargs"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.latents",description:`<strong>latents</strong> (<code>torch.Tensor</code>, or <code>list[torch.Tensor]</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Latent noise tensors to replace the random initialization. These can be taken from the previous | |
| function call’s output.`,name:"latents"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.generator",description:`<strong>generator</strong> (<code>torch.Generator</code>, or <code>list[torch.Generator]</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Random number generator object to ensure reproducibility.`,name:"generator"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.output_type",description:`<strong>output_type</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"np"</code>) — | |
| Preferred format of the output’s <code>prediction</code> and the optional <code>uncertainty</code> fields. The accepted | |
| values are: <code>"np"</code> (numpy array) or <code>"pt"</code> (torch tensor).`,name:"output_type"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.output_uncertainty",description:`<strong>output_uncertainty</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) — | |
| When enabled, the output’s <code>uncertainty</code> field contains the predictive uncertainty map, provided that | |
| the <code>ensemble_size</code> argument is set to a value above 2.`,name:"output_uncertainty"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.output_latent",description:`<strong>output_latent</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) — | |
| When enabled, the output’s <code>latent</code> field contains the latent codes corresponding to the predictions | |
| within the ensemble. These codes can be saved, modified, and used for subsequent calls with the | |
| <code>latents</code> argument.`,name:"output_latent"},{anchor:"diffusers.MarigoldDepthPipeline.__call__.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether or not to return a <a href="/docs/diffusers/v0.37.1/en/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldDepthOutput">MarigoldDepthOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/v0.37.1/src/diffusers/pipelines/marigold/pipeline_marigold_depth.py#L347",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p>If <code>return_dict</code> is <code>True</code>, <a | |
| href="/docs/diffusers/v0.37.1/en/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldDepthOutput" | |
| >MarigoldDepthOutput</a> is returned, otherwise a | |
| <code>tuple</code> is returned where the first element is the prediction, the second element is the uncertainty | |
| (or <code>None</code>), and the third is the latent (or <code>None</code>).</p> | |
| `,returnType:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p><a | |
| href="/docs/diffusers/v0.37.1/en/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldDepthOutput" | |
| >MarigoldDepthOutput</a> or <code>tuple</code></p> | |
| `}}),S=new Et({props:{anchor:"diffusers.MarigoldDepthPipeline.__call__.example",$$slots:{default:[gn]},$$scope:{ctx:C}}}),ge=new q({props:{name:"class diffusers.pipelines.marigold.MarigoldDepthOutput",anchor:"diffusers.pipelines.marigold.MarigoldDepthOutput",parameters:[{name:"prediction",val:": numpy.ndarray | torch.Tensor"},{name:"uncertainty",val:": None | numpy.ndarray | torch.Tensor"},{name:"latent",val:": None | torch.Tensor"}],parametersDescription:[{anchor:"diffusers.pipelines.marigold.MarigoldDepthOutput.prediction",description:`<strong>prediction</strong> (<code>np.ndarray</code>, <code>torch.Tensor</code>) — | |
| Predicted depth maps with values in the range [0, 1]. The shape is <code>numimages × 1 × height × width</code> for | |
| <code>torch.Tensor</code> or <code>numimages × height × width × 1</code> for <code>np.ndarray</code>.`,name:"prediction"},{anchor:"diffusers.pipelines.marigold.MarigoldDepthOutput.uncertainty",description:`<strong>uncertainty</strong> (<code>None</code>, <code>np.ndarray</code>, <code>torch.Tensor</code>) — | |
| Uncertainty maps computed from the ensemble, with values in the range [0, 1]. The shape is <code>numimages × 1 × height × width</code> for <code>torch.Tensor</code> or <code>numimages × height × width × 1</code> for <code>np.ndarray</code>.`,name:"uncertainty"},{anchor:"diffusers.pipelines.marigold.MarigoldDepthOutput.latent",description:`<strong>latent</strong> (<code>None</code>, <code>torch.Tensor</code>) — | |
| Latent features corresponding to the predictions, compatible with the <code>latents</code> argument of the pipeline. | |
| The shape is <code>numimages * numensemble × 4 × latentheight × latentwidth</code>.`,name:"latent"}],source:"https://github.com/huggingface/diffusers/blob/v0.37.1/src/diffusers/pipelines/marigold/pipeline_marigold_depth.py#L83"}}),he=new q({props:{name:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_depth",anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_depth",parameters:[{name:"depth",val:": PIL.Image.Image | numpy.ndarray | torch.Tensor | list[PIL.Image.Image] | list[numpy.ndarray] | list[torch.Tensor]"},{name:"val_min",val:": float = 0.0"},{name:"val_max",val:": float = 1.0"},{name:"color_map",val:": str = 'Spectral'"}],parametersDescription:[{anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_depth.depth",description:"<strong>depth</strong> (<code>PIL.Image.Image | np.ndarray | torch.Tensor | list[PIL.Image.Image, list[np.ndarray], -- list[torch.Tensor]]</code>): Depth maps.",name:"depth"},{anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_depth.val_min",description:"<strong>val_min</strong> (<code>float</code>, <em>optional</em>, defaults to <code>0.0</code>) — Minimum value of the visualized depth range.",name:"val_min"},{anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_depth.val_max",description:"<strong>val_max</strong> (<code>float</code>, <em>optional</em>, defaults to <code>1.0</code>) — Maximum value of the visualized depth range.",name:"val_max"},{anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_depth.color_map",description:`<strong>color_map</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"Spectral"</code>) — Color map used to convert a single-channel | |
| depth prediction into colored representation.`,name:"color_map"}],source:"https://github.com/huggingface/diffusers/blob/v0.37.1/src/diffusers/pipelines/marigold/marigold_image_processing.py#L387"}}),fe=new it({props:{title:"Marigold Normals Estimation API",local:"diffusers.MarigoldNormalsPipeline",headingTag:"h2"}}),_e=new q({props:{name:"class diffusers.MarigoldNormalsPipeline",anchor:"diffusers.MarigoldNormalsPipeline",parameters:[{name:"unet",val:": UNet2DConditionModel"},{name:"vae",val:": AutoencoderKL"},{name:"scheduler",val:": diffusers.schedulers.scheduling_ddim.DDIMScheduler | diffusers.schedulers.scheduling_lcm.LCMScheduler"},{name:"text_encoder",val:": CLIPTextModel"},{name:"tokenizer",val:": CLIPTokenizer"},{name:"prediction_type",val:": str | None = None"},{name:"use_full_z_range",val:": bool | None = True"},{name:"default_denoising_steps",val:": int | None = None"},{name:"default_processing_resolution",val:": int | None = None"}],parametersDescription:[{anchor:"diffusers.MarigoldNormalsPipeline.unet",description:`<strong>unet</strong> (<code>UNet2DConditionModel</code>) — | |
| Conditional U-Net to denoise the normals latent, conditioned on image latent.`,name:"unet"},{anchor:"diffusers.MarigoldNormalsPipeline.vae",description:`<strong>vae</strong> (<code>AutoencoderKL</code>) — | |
| Variational Auto-Encoder (VAE) Model to encode and decode images and predictions to and from latent | |
| representations.`,name:"vae"},{anchor:"diffusers.MarigoldNormalsPipeline.scheduler",description:`<strong>scheduler</strong> (<code>DDIMScheduler</code> or <code>LCMScheduler</code>) — | |
| A scheduler to be used in combination with <code>unet</code> to denoise the encoded image latents.`,name:"scheduler"},{anchor:"diffusers.MarigoldNormalsPipeline.text_encoder",description:`<strong>text_encoder</strong> (<code>CLIPTextModel</code>) — | |
| Text-encoder, for empty text embedding.`,name:"text_encoder"},{anchor:"diffusers.MarigoldNormalsPipeline.tokenizer",description:`<strong>tokenizer</strong> (<code>CLIPTokenizer</code>) — | |
| CLIP tokenizer.`,name:"tokenizer"},{anchor:"diffusers.MarigoldNormalsPipeline.prediction_type",description:`<strong>prediction_type</strong> (<code>str</code>, <em>optional</em>) — | |
| Type of predictions made by the model.`,name:"prediction_type"},{anchor:"diffusers.MarigoldNormalsPipeline.use_full_z_range",description:`<strong>use_full_z_range</strong> (<code>bool</code>, <em>optional</em>) — | |
| Whether the normals predicted by this model utilize the full range of the Z dimension, or only its positive | |
| half.`,name:"use_full_z_range"},{anchor:"diffusers.MarigoldNormalsPipeline.default_denoising_steps",description:`<strong>default_denoising_steps</strong> (<code>int</code>, <em>optional</em>) — | |
| The minimum number of denoising diffusion steps that are required to produce a prediction of reasonable | |
| quality with the given model. This value must be set in the model config. When the pipeline is called | |
| without explicitly setting <code>num_inference_steps</code>, the default value is used. This is required to ensure | |
| reasonable results with various model flavors compatible with the pipeline, such as those relying on very | |
| short denoising schedules (<code>LCMScheduler</code>) and those with full diffusion schedules (<code>DDIMScheduler</code>).`,name:"default_denoising_steps"},{anchor:"diffusers.MarigoldNormalsPipeline.default_processing_resolution",description:`<strong>default_processing_resolution</strong> (<code>int</code>, <em>optional</em>) — | |
| The recommended value of the <code>processing_resolution</code> parameter of the pipeline. This value must be set in | |
| the model config. When the pipeline is called without explicitly setting <code>processing_resolution</code>, the | |
| default value is used. This is required to ensure reasonable results with various model flavors trained | |
| with varying optimal processing resolution values.`,name:"default_processing_resolution"}],source:"https://github.com/huggingface/diffusers/blob/v0.37.1/src/diffusers/pipelines/marigold/pipeline_marigold_normals.py#L99"}}),ve=new q({props:{name:"__call__",anchor:"diffusers.MarigoldNormalsPipeline.__call__",parameters:[{name:"image",val:": PIL.Image.Image | numpy.ndarray | torch.Tensor | list[PIL.Image.Image] | list[numpy.ndarray] | list[torch.Tensor]"},{name:"num_inference_steps",val:": int | None = None"},{name:"ensemble_size",val:": int = 1"},{name:"processing_resolution",val:": int | None = None"},{name:"match_input_resolution",val:": bool = True"},{name:"resample_method_input",val:": str = 'bilinear'"},{name:"resample_method_output",val:": str = 'bilinear'"},{name:"batch_size",val:": int = 1"},{name:"ensembling_kwargs",val:": dict[str, typing.Any] | None = None"},{name:"latents",val:": torch.Tensor | list[torch.Tensor] | None = None"},{name:"generator",val:": torch._C.Generator | list[torch._C.Generator] | None = None"},{name:"output_type",val:": str = 'np'"},{name:"output_uncertainty",val:": bool = False"},{name:"output_latent",val:": bool = False"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.MarigoldNormalsPipeline.__call__.image",description:`<strong>image</strong> (<code>PIL.Image.Image</code>, <code>np.ndarray</code>, <code>torch.Tensor</code>, <code>list[PIL.Image.Image]</code>, <code>list[np.ndarray]</code>), — | |
| <code>list[torch.Tensor]</code>: An input image or images used as an input for the normals estimation task. For | |
| arrays and tensors, the expected value range is between <code>[0, 1]</code>. Passing a batch of images is possible | |
| by providing a four-dimensional array or a tensor. Additionally, a list of images of two- or | |
| three-dimensional arrays or tensors can be passed. In the latter case, all list elements must have the | |
| same width and height.`,name:"image"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Number of denoising diffusion steps during inference. The default value <code>None</code> results in automatic | |
| selection.`,name:"num_inference_steps"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.ensemble_size",description:`<strong>ensemble_size</strong> (<code>int</code>, defaults to <code>1</code>) — | |
| Number of ensemble predictions. Higher values result in measurable improvements and visual degradation.`,name:"ensemble_size"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.processing_resolution",description:`<strong>processing_resolution</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Effective processing resolution. When set to <code>0</code>, matches the larger input image dimension. This | |
| produces crisper predictions, but may also lead to the overall loss of global context. The default | |
| value <code>None</code> resolves to the optimal value from the model config.`,name:"processing_resolution"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.match_input_resolution",description:`<strong>match_input_resolution</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| When enabled, the output prediction is resized to match the input dimensions. When disabled, the longer | |
| side of the output will equal to <code>processing_resolution</code>.`,name:"match_input_resolution"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.resample_method_input",description:`<strong>resample_method_input</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"bilinear"</code>) — | |
| Resampling method used to resize input images to <code>processing_resolution</code>. The accepted values are: | |
| <code>"nearest"</code>, <code>"nearest-exact"</code>, <code>"bilinear"</code>, <code>"bicubic"</code>, or <code>"area"</code>.`,name:"resample_method_input"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.resample_method_output",description:`<strong>resample_method_output</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"bilinear"</code>) — | |
| Resampling method used to resize output predictions to match the input resolution. The accepted values | |
| are <code>"nearest"</code>, <code>"nearest-exact"</code>, <code>"bilinear"</code>, <code>"bicubic"</code>, or <code>"area"</code>.`,name:"resample_method_output"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.batch_size",description:`<strong>batch_size</strong> (<code>int</code>, <em>optional</em>, defaults to <code>1</code>) — | |
| Batch size; only matters when setting <code>ensemble_size</code> or passing a tensor of images.`,name:"batch_size"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.ensembling_kwargs",description:`<strong>ensembling_kwargs</strong> (<code>dict</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Extra dictionary with arguments for precise ensembling control. The following options are available: | |
| <ul> | |
| <li>reduction (<code>str</code>, <em>optional</em>, defaults to <code>"closest"</code>): Defines the ensembling function applied in | |
| every pixel location, can be either <code>"closest"</code> or <code>"mean"</code>.</li> | |
| </ul>`,name:"ensembling_kwargs"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.latents",description:`<strong>latents</strong> (<code>torch.Tensor</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Latent noise tensors to replace the random initialization. These can be taken from the previous | |
| function call’s output.`,name:"latents"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.generator",description:`<strong>generator</strong> (<code>torch.Generator</code>, or <code>list[torch.Generator]</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Random number generator object to ensure reproducibility.`,name:"generator"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.output_type",description:`<strong>output_type</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"np"</code>) — | |
| Preferred format of the output’s <code>prediction</code> and the optional <code>uncertainty</code> fields. The accepted | |
| values are: <code>"np"</code> (numpy array) or <code>"pt"</code> (torch tensor).`,name:"output_type"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.output_uncertainty",description:`<strong>output_uncertainty</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) — | |
| When enabled, the output’s <code>uncertainty</code> field contains the predictive uncertainty map, provided that | |
| the <code>ensemble_size</code> argument is set to a value above 2.`,name:"output_uncertainty"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.output_latent",description:`<strong>output_latent</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) — | |
| When enabled, the output’s <code>latent</code> field contains the latent codes corresponding to the predictions | |
| within the ensemble. These codes can be saved, modified, and used for subsequent calls with the | |
| <code>latents</code> argument.`,name:"output_latent"},{anchor:"diffusers.MarigoldNormalsPipeline.__call__.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether or not to return a <a href="/docs/diffusers/v0.37.1/en/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldNormalsOutput">MarigoldNormalsOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/v0.37.1/src/diffusers/pipelines/marigold/pipeline_marigold_normals.py#L332",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p>If <code>return_dict</code> is <code>True</code>, <a | |
| href="/docs/diffusers/v0.37.1/en/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldNormalsOutput" | |
| >MarigoldNormalsOutput</a> is returned, otherwise a | |
| <code>tuple</code> is returned where the first element is the prediction, the second element is the uncertainty | |
| (or <code>None</code>), and the third is the latent (or <code>None</code>).</p> | |
| `,returnType:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p><a | |
| href="/docs/diffusers/v0.37.1/en/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldNormalsOutput" | |
| >MarigoldNormalsOutput</a> or <code>tuple</code></p> | |
| `}}),X=new Et({props:{anchor:"diffusers.MarigoldNormalsPipeline.__call__.example",$$slots:{default:[hn]},$$scope:{ctx:C}}}),be=new q({props:{name:"class diffusers.pipelines.marigold.MarigoldNormalsOutput",anchor:"diffusers.pipelines.marigold.MarigoldNormalsOutput",parameters:[{name:"prediction",val:": numpy.ndarray | torch.Tensor"},{name:"uncertainty",val:": None | numpy.ndarray | torch.Tensor"},{name:"latent",val:": None | torch.Tensor"}],parametersDescription:[{anchor:"diffusers.pipelines.marigold.MarigoldNormalsOutput.prediction",description:`<strong>prediction</strong> (<code>np.ndarray</code>, <code>torch.Tensor</code>) — | |
| Predicted normals with values in the range [-1, 1]. The shape is <code>numimages × 3 × height × width</code> for | |
| <code>torch.Tensor</code> or <code>numimages × height × width × 3</code> for <code>np.ndarray</code>.`,name:"prediction"},{anchor:"diffusers.pipelines.marigold.MarigoldNormalsOutput.uncertainty",description:`<strong>uncertainty</strong> (<code>None</code>, <code>np.ndarray</code>, <code>torch.Tensor</code>) — | |
| Uncertainty maps computed from the ensemble, with values in the range [0, 1]. The shape is <code>numimages × 1 × height × width</code> for <code>torch.Tensor</code> or <code>numimages × height × width × 1</code> for <code>np.ndarray</code>.`,name:"uncertainty"},{anchor:"diffusers.pipelines.marigold.MarigoldNormalsOutput.latent",description:`<strong>latent</strong> (<code>None</code>, <code>torch.Tensor</code>) — | |
| Latent features corresponding to the predictions, compatible with the <code>latents</code> argument of the pipeline. | |
| The shape is <code>numimages * numensemble × 4 × latentheight × latentwidth</code>.`,name:"latent"}],source:"https://github.com/huggingface/diffusers/blob/v0.37.1/src/diffusers/pipelines/marigold/pipeline_marigold_normals.py#L78"}}),Me=new q({props:{name:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_normals",anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_normals",parameters:[{name:"normals",val:": numpy.ndarray | torch.Tensor | list[numpy.ndarray] | list[torch.Tensor]"},{name:"flip_x",val:": bool = False"},{name:"flip_y",val:": bool = False"},{name:"flip_z",val:": bool = False"}],parametersDescription:[{anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_normals.normals",description:`<strong>normals</strong> (<code>np.ndarray | torch.Tensor | list[np.ndarray, list[torch.Tensor]]</code>) — | |
| Surface normals.`,name:"normals"},{anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_normals.flip_x",description:`<strong>flip_x</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) — Flips the X axis of the normals frame of reference. | |
| Default direction is right.`,name:"flip_x"},{anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_normals.flip_y",description:`<strong>flip_y</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) — Flips the Y axis of the normals frame of reference. | |
| Default direction is top.`,name:"flip_y"},{anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_normals.flip_z",description:`<strong>flip_z</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) — Flips the Z axis of the normals frame of reference. | |
| Default direction is facing the observer.`,name:"flip_z"}],source:"https://github.com/huggingface/diffusers/blob/v0.37.1/src/diffusers/pipelines/marigold/marigold_image_processing.py#L486"}}),ye=new it({props:{title:"Marigold Intrinsic Image Decomposition API",local:"diffusers.MarigoldIntrinsicsPipeline",headingTag:"h2"}}),we=new q({props:{name:"class diffusers.MarigoldIntrinsicsPipeline",anchor:"diffusers.MarigoldIntrinsicsPipeline",parameters:[{name:"unet",val:": UNet2DConditionModel"},{name:"vae",val:": AutoencoderKL"},{name:"scheduler",val:": diffusers.schedulers.scheduling_ddim.DDIMScheduler | diffusers.schedulers.scheduling_lcm.LCMScheduler"},{name:"text_encoder",val:": CLIPTextModel"},{name:"tokenizer",val:": CLIPTokenizer"},{name:"prediction_type",val:": str | None = None"},{name:"target_properties",val:": dict[str, typing.Any] | None = None"},{name:"default_denoising_steps",val:": int | None = None"},{name:"default_processing_resolution",val:": int | None = None"}],parametersDescription:[{anchor:"diffusers.MarigoldIntrinsicsPipeline.unet",description:`<strong>unet</strong> (<code>UNet2DConditionModel</code>) — | |
| Conditional U-Net to denoise the targets latent, conditioned on image latent.`,name:"unet"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.vae",description:`<strong>vae</strong> (<code>AutoencoderKL</code>) — | |
| Variational Auto-Encoder (VAE) Model to encode and decode images and predictions to and from latent | |
| representations.`,name:"vae"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.scheduler",description:`<strong>scheduler</strong> (<code>DDIMScheduler</code> or <code>LCMScheduler</code>) — | |
| A scheduler to be used in combination with <code>unet</code> to denoise the encoded image latents.`,name:"scheduler"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.text_encoder",description:`<strong>text_encoder</strong> (<code>CLIPTextModel</code>) — | |
| Text-encoder, for empty text embedding.`,name:"text_encoder"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.tokenizer",description:`<strong>tokenizer</strong> (<code>CLIPTokenizer</code>) — | |
| CLIP tokenizer.`,name:"tokenizer"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.prediction_type",description:`<strong>prediction_type</strong> (<code>str</code>, <em>optional</em>) — | |
| Type of predictions made by the model.`,name:"prediction_type"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.target_properties",description:`<strong>target_properties</strong> (<code>dict[str, Any]</code>, <em>optional</em>) — | |
| Properties of the predicted modalities, such as <code>target_names</code>, a <code>list[str]</code> used to define the number, | |
| order and names of the predicted modalities, and any other metadata that may be required to interpret the | |
| predictions.`,name:"target_properties"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.default_denoising_steps",description:`<strong>default_denoising_steps</strong> (<code>int</code>, <em>optional</em>) — | |
| The minimum number of denoising diffusion steps that are required to produce a prediction of reasonable | |
| quality with the given model. This value must be set in the model config. When the pipeline is called | |
| without explicitly setting <code>num_inference_steps</code>, the default value is used. This is required to ensure | |
| reasonable results with various model flavors compatible with the pipeline, such as those relying on very | |
| short denoising schedules (<code>LCMScheduler</code>) and those with full diffusion schedules (<code>DDIMScheduler</code>).`,name:"default_denoising_steps"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.default_processing_resolution",description:`<strong>default_processing_resolution</strong> (<code>int</code>, <em>optional</em>) — | |
| The recommended value of the <code>processing_resolution</code> parameter of the pipeline. This value must be set in | |
| the model config. When the pipeline is called without explicitly setting <code>processing_resolution</code>, the | |
| default value is used. This is required to ensure reasonable results with various model flavors trained | |
| with varying optimal processing resolution values.`,name:"default_processing_resolution"}],source:"https://github.com/huggingface/diffusers/blob/v0.37.1/src/diffusers/pipelines/marigold/pipeline_marigold_intrinsics.py#L120"}}),xe=new q({props:{name:"__call__",anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__",parameters:[{name:"image",val:": PIL.Image.Image | numpy.ndarray | torch.Tensor | list[PIL.Image.Image] | list[numpy.ndarray] | list[torch.Tensor]"},{name:"num_inference_steps",val:": int | None = None"},{name:"ensemble_size",val:": int = 1"},{name:"processing_resolution",val:": int | None = None"},{name:"match_input_resolution",val:": bool = True"},{name:"resample_method_input",val:": str = 'bilinear'"},{name:"resample_method_output",val:": str = 'bilinear'"},{name:"batch_size",val:": int = 1"},{name:"ensembling_kwargs",val:": dict[str, typing.Any] | None = None"},{name:"latents",val:": torch.Tensor | list[torch.Tensor] | None = None"},{name:"generator",val:": torch._C.Generator | list[torch._C.Generator] | None = None"},{name:"output_type",val:": str = 'np'"},{name:"output_uncertainty",val:": bool = False"},{name:"output_latent",val:": bool = False"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.image",description:`<strong>image</strong> (<code>PIL.Image.Image</code>, <code>np.ndarray</code>, <code>torch.Tensor</code>, <code>list[PIL.Image.Image]</code>, <code>list[np.ndarray]</code>), — | |
| <code>list[torch.Tensor]</code>: An input image or images used as an input for the intrinsic decomposition task. | |
| For arrays and tensors, the expected value range is between <code>[0, 1]</code>. Passing a batch of images is | |
| possible by providing a four-dimensional array or a tensor. Additionally, a list of images of two- or | |
| three-dimensional arrays or tensors can be passed. In the latter case, all list elements must have the | |
| same width and height.`,name:"image"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Number of denoising diffusion steps during inference. The default value <code>None</code> results in automatic | |
| selection.`,name:"num_inference_steps"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.ensemble_size",description:`<strong>ensemble_size</strong> (<code>int</code>, defaults to <code>1</code>) — | |
| Number of ensemble predictions. Higher values result in measurable improvements and visual degradation.`,name:"ensemble_size"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.processing_resolution",description:`<strong>processing_resolution</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Effective processing resolution. When set to <code>0</code>, matches the larger input image dimension. This | |
| produces crisper predictions, but may also lead to the overall loss of global context. The default | |
| value <code>None</code> resolves to the optimal value from the model config.`,name:"processing_resolution"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.match_input_resolution",description:`<strong>match_input_resolution</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| When enabled, the output prediction is resized to match the input dimensions. When disabled, the longer | |
| side of the output will equal to <code>processing_resolution</code>.`,name:"match_input_resolution"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.resample_method_input",description:`<strong>resample_method_input</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"bilinear"</code>) — | |
| Resampling method used to resize input images to <code>processing_resolution</code>. The accepted values are: | |
| <code>"nearest"</code>, <code>"nearest-exact"</code>, <code>"bilinear"</code>, <code>"bicubic"</code>, or <code>"area"</code>.`,name:"resample_method_input"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.resample_method_output",description:`<strong>resample_method_output</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"bilinear"</code>) — | |
| Resampling method used to resize output predictions to match the input resolution. The accepted values | |
| are <code>"nearest"</code>, <code>"nearest-exact"</code>, <code>"bilinear"</code>, <code>"bicubic"</code>, or <code>"area"</code>.`,name:"resample_method_output"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.batch_size",description:`<strong>batch_size</strong> (<code>int</code>, <em>optional</em>, defaults to <code>1</code>) — | |
| Batch size; only matters when setting <code>ensemble_size</code> or passing a tensor of images.`,name:"batch_size"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.ensembling_kwargs",description:`<strong>ensembling_kwargs</strong> (<code>dict</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Extra dictionary with arguments for precise ensembling control. The following options are available: | |
| <ul> | |
| <li>reduction (<code>str</code>, <em>optional</em>, defaults to <code>"median"</code>): Defines the ensembling function applied in | |
| every pixel location, can be either <code>"median"</code> or <code>"mean"</code>.</li> | |
| </ul>`,name:"ensembling_kwargs"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.latents",description:`<strong>latents</strong> (<code>torch.Tensor</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Latent noise tensors to replace the random initialization. These can be taken from the previous | |
| function call’s output.`,name:"latents"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.generator",description:`<strong>generator</strong> (<code>torch.Generator</code>, or <code>list[torch.Generator]</code>, <em>optional</em>, defaults to <code>None</code>) — | |
| Random number generator object to ensure reproducibility.`,name:"generator"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.output_type",description:`<strong>output_type</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"np"</code>) — | |
| Preferred format of the output’s <code>prediction</code> and the optional <code>uncertainty</code> fields. The accepted | |
| values are: <code>"np"</code> (numpy array) or <code>"pt"</code> (torch tensor).`,name:"output_type"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.output_uncertainty",description:`<strong>output_uncertainty</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) — | |
| When enabled, the output’s <code>uncertainty</code> field contains the predictive uncertainty map, provided that | |
| the <code>ensemble_size</code> argument is set to a value above 2.`,name:"output_uncertainty"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.output_latent",description:`<strong>output_latent</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) — | |
| When enabled, the output’s <code>latent</code> field contains the latent codes corresponding to the predictions | |
| within the ensemble. These codes can be saved, modified, and used for subsequent calls with the | |
| <code>latents</code> argument.`,name:"output_latent"},{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether or not to return a <a href="/docs/diffusers/v0.37.1/en/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldIntrinsicsOutput">MarigoldIntrinsicsOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/v0.37.1/src/diffusers/pipelines/marigold/pipeline_marigold_intrinsics.py#L359",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p>If <code>return_dict</code> is <code>True</code>, <a | |
| href="/docs/diffusers/v0.37.1/en/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldIntrinsicsOutput" | |
| >MarigoldIntrinsicsOutput</a> is returned, otherwise a | |
| <code>tuple</code> is returned where the first element is the prediction, the second element is the uncertainty | |
| (or <code>None</code>), and the third is the latent (or <code>None</code>).</p> | |
| `,returnType:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p><a | |
| href="/docs/diffusers/v0.37.1/en/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldIntrinsicsOutput" | |
| >MarigoldIntrinsicsOutput</a> or <code>tuple</code></p> | |
| `}}),F=new Et({props:{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.example",$$slots:{default:[fn]},$$scope:{ctx:C}}}),Y=new Et({props:{anchor:"diffusers.MarigoldIntrinsicsPipeline.__call__.example-2",$$slots:{default:[_n]},$$scope:{ctx:C}}}),Te=new q({props:{name:"class diffusers.pipelines.marigold.MarigoldIntrinsicsOutput",anchor:"diffusers.pipelines.marigold.MarigoldIntrinsicsOutput",parameters:[{name:"prediction",val:": numpy.ndarray | torch.Tensor"},{name:"uncertainty",val:": None | numpy.ndarray | torch.Tensor"},{name:"latent",val:": None | torch.Tensor"}],parametersDescription:[{anchor:"diffusers.pipelines.marigold.MarigoldIntrinsicsOutput.prediction",description:`<strong>prediction</strong> (<code>np.ndarray</code>, <code>torch.Tensor</code>) — | |
| Predicted image intrinsics with values in the range [0, 1]. The shape is <code>(numimages * numtargets) × 3 × height × width</code> for <code>torch.Tensor</code> or <code>(numimages * numtargets) × height × width × 3</code> for <code>np.ndarray</code>, | |
| where <code>numtargets</code> corresponds to the number of predicted target modalities of the intrinsic image | |
| decomposition.`,name:"prediction"},{anchor:"diffusers.pipelines.marigold.MarigoldIntrinsicsOutput.uncertainty",description:`<strong>uncertainty</strong> (<code>None</code>, <code>np.ndarray</code>, <code>torch.Tensor</code>) — | |
| Uncertainty maps computed from the ensemble, with values in the range [0, 1]. The shape is <code>(numimages * numtargets) × 3 × height × width</code> for <code>torch.Tensor</code> or <code>(numimages * numtargets) × height × width × 3</code> for | |
| <code>np.ndarray</code>.`,name:"uncertainty"},{anchor:"diffusers.pipelines.marigold.MarigoldIntrinsicsOutput.latent",description:`<strong>latent</strong> (<code>None</code>, <code>torch.Tensor</code>) — | |
| Latent features corresponding to the predictions, compatible with the <code>latents</code> argument of the pipeline. | |
| The shape is <code>(numimages * numensemble) × (numtargets * 4) × latentheight × latentwidth</code>.`,name:"latent"}],source:"https://github.com/huggingface/diffusers/blob/v0.37.1/src/diffusers/pipelines/marigold/pipeline_marigold_intrinsics.py#L96"}}),Ie=new q({props:{name:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_intrinsics",anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_intrinsics",parameters:[{name:"prediction",val:": numpy.ndarray | torch.Tensor | list[numpy.ndarray] | list[torch.Tensor]"},{name:"target_properties",val:": dict"},{name:"color_map",val:": str | dict[str, str] = 'binary'"}],parametersDescription:[{anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_intrinsics.prediction",description:`<strong>prediction</strong> (<code>np.ndarray | torch.Tensor | list[np.ndarray, list[torch.Tensor]]</code>) — | |
| Intrinsic image decomposition.`,name:"prediction"},{anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_intrinsics.target_properties",description:`<strong>target_properties</strong> (<code>dict[str, Any]</code>) — | |
| Decomposition properties. Expected entries: <code>target_names: list[str]</code> and a dictionary with keys | |
| <code>prediction_space: str</code>, <code>sub_target_names: list[str | Null]</code> (must have 3 entries, null for missing | |
| modalities), <code>up_to_scale: bool</code>, one for each target and sub-target.`,name:"target_properties"},{anchor:"diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_intrinsics.color_map",description:`<strong>color_map</strong> (<code>str | dict[str, str]</code>, <em>optional</em>, defaults to <code>"Spectral"</code>) — | |
| Color map used to convert a single-channel predictions into colored representations. When a dictionary | |
| is passed, each modality can be colored with its own color map.`,name:"color_map"}],source:"https://github.com/huggingface/diffusers/blob/v0.37.1/src/diffusers/pipelines/marigold/marigold_image_processing.py#L542"}}),$e=new mn({props:{source:"https://github.com/huggingface/diffusers/blob/main/docs/source/en/api/pipelines/marigold.md"}}),{c(){c=r("meta"),w=i(),u=r("p"),m=i(),g(M.$$.fragment),d=i(),g(y.$$.fragment),at=i(),te=r("p"),te.innerHTML=yo,rt=i(),oe=r("p"),oe.innerHTML=wo,lt=i(),ne=r("p"),ne.innerHTML=xo,dt=i(),U=r("blockquote"),U.innerHTML=To,ct=i(),g(ie.$$.fragment),pt=i(),se=r("p"),se.textContent=Io,ut=i(),ae=r("table"),ae.innerHTML=$o,mt=i(),g(re.$$.fragment),gt=i(),le=r("p"),le.innerHTML=No,ht=i(),V=r("table"),qe=r("thead"),qe.innerHTML=Po,Rt=i(),D=r("tbody"),De=r("tr"),De.innerHTML=qo,Ut=i(),Je=r("tr"),Je.innerHTML=Do,Vt=i(),ze=r("tr"),ze.innerHTML=Jo,Bt=i(),Z=r("tr"),ke=r("td"),ke.innerHTML=zo,At=i(),Le=r("td"),Le.textContent=ko,St=i(),de=r("td"),Xt=tn("HyperSim decomposition of an image "),ft=new dn(!1),_t=tn(" is comprised of Albedo $A$, Diffuse shading $S$, and Non-diffuse residual $R$: $I = A*S+R$."),vt=i(),B=r("blockquote"),B.innerHTML=Lo,bt=i(),A=r("blockquote"),A.innerHTML=Co,Mt=i(),ce=r("p"),ce.innerHTML=jo,yt=i(),g(pe.$$.fragment),wt=i(),I=r("div"),g(ue.$$.fragment),Ft=i(),Ce=r("p"),Ce.innerHTML=Wo,Yt=i(),je=r("p"),je.innerHTML=Zo,Ot=i(),j=r("div"),g(me.$$.fragment),Qt=i(),We=r("p"),We.textContent=Eo,Kt=i(),g(S.$$.fragment),xt=i(),E=r("div"),g(ge.$$.fragment),eo=i(),Ze=r("p"),Ze.textContent=Ho,Tt=i(),J=r("div"),g(he.$$.fragment),to=i(),Ee=r("p"),Ee.innerHTML=Go,oo=i(),He=r("p"),He.innerHTML=Ro,It=i(),g(fe.$$.fragment),$t=i(),$=r("div"),g(_e.$$.fragment),no=i(),Ge=r("p"),Ge.innerHTML=Uo,io=i(),Re=r("p"),Re.innerHTML=Vo,so=i(),W=r("div"),g(ve.$$.fragment),ao=i(),Ue=r("p"),Ue.textContent=Bo,ro=i(),g(X.$$.fragment),Nt=i(),H=r("div"),g(be.$$.fragment),lo=i(),Ve=r("p"),Ve.textContent=Ao,Pt=i(),z=r("div"),g(Me.$$.fragment),co=i(),Be=r("p"),Be.innerHTML=So,po=i(),Ae=r("p"),Ae.innerHTML=Xo,qt=i(),g(ye.$$.fragment),Dt=i(),N=r("div"),g(we.$$.fragment),uo=i(),Se=r("p"),Se.innerHTML=Fo,mo=i(),Xe=r("p"),Xe.innerHTML=Yo,go=i(),P=r("div"),g(xe.$$.fragment),ho=i(),Fe=r("p"),Fe.textContent=Oo,fo=i(),g(F.$$.fragment),_o=i(),g(Y.$$.fragment),Jt=i(),G=r("div"),g(Te.$$.fragment),vo=i(),Ye=r("p"),Ye.textContent=Qo,zt=i(),k=r("div"),g(Ie.$$.fragment),bo=i(),Oe=r("p"),Oe.innerHTML=Ko,Mo=i(),Qe=r("p"),Qe.innerHTML=en,kt=i(),g($e.$$.fragment),Lt=i(),st=r("p"),this.h()},l(e){const o=cn("svelte-u9bgzb",document.head);c=l(o,"META",{name:!0,content:!0}),o.forEach(t),w=s(e),u=l(e,"P",{}),x(u).forEach(t),m=s(e),h(M.$$.fragment,e),d=s(e),h(y.$$.fragment,e),at=s(e),te=l(e,"P",{"data-svelte-h":!0}),p(te)!=="svelte-1musivh"&&(te.innerHTML=yo),rt=s(e),oe=l(e,"P",{"data-svelte-h":!0}),p(oe)!=="svelte-z53d30"&&(oe.innerHTML=wo),lt=s(e),ne=l(e,"P",{"data-svelte-h":!0}),p(ne)!=="svelte-pdh9wl"&&(ne.innerHTML=xo),dt=s(e),U=l(e,"BLOCKQUOTE",{class:!0,"data-svelte-h":!0}),p(U)!=="svelte-ujnrla"&&(U.innerHTML=To),ct=s(e),h(ie.$$.fragment,e),pt=s(e),se=l(e,"P",{"data-svelte-h":!0}),p(se)!=="svelte-d9hh6k"&&(se.textContent=Io),ut=s(e),ae=l(e,"TABLE",{"data-svelte-h":!0}),p(ae)!=="svelte-1puk2lq"&&(ae.innerHTML=$o),mt=s(e),h(re.$$.fragment,e),gt=s(e),le=l(e,"P",{"data-svelte-h":!0}),p(le)!=="svelte-1w30tm5"&&(le.innerHTML=No),ht=s(e),V=l(e,"TABLE",{});var Ne=x(V);qe=l(Ne,"THEAD",{"data-svelte-h":!0}),p(qe)!=="svelte-ubewwm"&&(qe.innerHTML=Po),Rt=s(Ne),D=l(Ne,"TBODY",{});var L=x(D);De=l(L,"TR",{"data-svelte-h":!0}),p(De)!=="svelte-ao7el9"&&(De.innerHTML=qo),Ut=s(L),Je=l(L,"TR",{"data-svelte-h":!0}),p(Je)!=="svelte-9wucso"&&(Je.innerHTML=Do),Vt=s(L),ze=l(L,"TR",{"data-svelte-h":!0}),p(ze)!=="svelte-1mu3nd5"&&(ze.innerHTML=Jo),Bt=s(L),Z=l(L,"TR",{});var R=x(Z);ke=l(R,"TD",{"data-svelte-h":!0}),p(ke)!=="svelte-1u8ffq5"&&(ke.innerHTML=zo),At=s(R),Le=l(R,"TD",{"data-svelte-h":!0}),p(Le)!=="svelte-pxwxqa"&&(Le.textContent=ko),St=s(R),de=l(R,"TD",{});var Pe=x(de);Xt=on(Pe,"HyperSim decomposition of an image "),ft=pn(Pe,!1),_t=on(Pe," is comprised of Albedo $A$, Diffuse shading $S$, and Non-diffuse residual $R$: $I = A*S+R$."),Pe.forEach(t),R.forEach(t),L.forEach(t),Ne.forEach(t),vt=s(e),B=l(e,"BLOCKQUOTE",{class:!0,"data-svelte-h":!0}),p(B)!=="svelte-1fuu6zv"&&(B.innerHTML=Lo),bt=s(e),A=l(e,"BLOCKQUOTE",{class:!0,"data-svelte-h":!0}),p(A)!=="svelte-cqgv7b"&&(A.innerHTML=Co),Mt=s(e),ce=l(e,"P",{"data-svelte-h":!0}),p(ce)!=="svelte-t30fxk"&&(ce.innerHTML=jo),yt=s(e),h(pe.$$.fragment,e),wt=s(e),I=l(e,"DIV",{class:!0});var O=x(I);h(ue.$$.fragment,O),Ft=s(O),Ce=l(O,"P",{"data-svelte-h":!0}),p(Ce)!=="svelte-41emwn"&&(Ce.innerHTML=Wo),Yt=s(O),je=l(O,"P",{"data-svelte-h":!0}),p(je)!=="svelte-47pdsf"&&(je.innerHTML=Zo),Ot=s(O),j=l(O,"DIV",{class:!0});var Ke=x(j);h(me.$$.fragment,Ke),Qt=s(Ke),We=l(Ke,"P",{"data-svelte-h":!0}),p(We)!=="svelte-typ793"&&(We.textContent=Eo),Kt=s(Ke),h(S.$$.fragment,Ke),Ke.forEach(t),O.forEach(t),xt=s(e),E=l(e,"DIV",{class:!0});var jt=x(E);h(ge.$$.fragment,jt),eo=s(jt),Ze=l(jt,"P",{"data-svelte-h":!0}),p(Ze)!=="svelte-zmov3r"&&(Ze.textContent=Ho),jt.forEach(t),Tt=s(e),J=l(e,"DIV",{class:!0});var et=x(J);h(he.$$.fragment,et),to=s(et),Ee=l(et,"P",{"data-svelte-h":!0}),p(Ee)!=="svelte-2rqpmx"&&(Ee.innerHTML=Go),oo=s(et),He=l(et,"P",{"data-svelte-h":!0}),p(He)!=="svelte-1dv37nj"&&(He.innerHTML=Ro),et.forEach(t),It=s(e),h(fe.$$.fragment,e),$t=s(e),$=l(e,"DIV",{class:!0});var Q=x($);h(_e.$$.fragment,Q),no=s(Q),Ge=l(Q,"P",{"data-svelte-h":!0}),p(Ge)!=="svelte-13lumts"&&(Ge.innerHTML=Uo),io=s(Q),Re=l(Q,"P",{"data-svelte-h":!0}),p(Re)!=="svelte-47pdsf"&&(Re.innerHTML=Vo),so=s(Q),W=l(Q,"DIV",{class:!0});var tt=x(W);h(ve.$$.fragment,tt),ao=s(tt),Ue=l(tt,"P",{"data-svelte-h":!0}),p(Ue)!=="svelte-typ793"&&(Ue.textContent=Bo),ro=s(tt),h(X.$$.fragment,tt),tt.forEach(t),Q.forEach(t),Nt=s(e),H=l(e,"DIV",{class:!0});var Wt=x(H);h(be.$$.fragment,Wt),lo=s(Wt),Ve=l(Wt,"P",{"data-svelte-h":!0}),p(Ve)!=="svelte-1msg7gm"&&(Ve.textContent=Ao),Wt.forEach(t),Pt=s(e),z=l(e,"DIV",{class:!0});var ot=x(z);h(Me.$$.fragment,ot),co=s(ot),Be=l(ot,"P",{"data-svelte-h":!0}),p(Be)!=="svelte-qt3ymb"&&(Be.innerHTML=So),po=s(ot),Ae=l(ot,"P",{"data-svelte-h":!0}),p(Ae)!=="svelte-lp521e"&&(Ae.innerHTML=Xo),ot.forEach(t),qt=s(e),h(ye.$$.fragment,e),Dt=s(e),N=l(e,"DIV",{class:!0});var K=x(N);h(we.$$.fragment,K),uo=s(K),Se=l(K,"P",{"data-svelte-h":!0}),p(Se)!=="svelte-15yl9op"&&(Se.innerHTML=Fo),mo=s(K),Xe=l(K,"P",{"data-svelte-h":!0}),p(Xe)!=="svelte-47pdsf"&&(Xe.innerHTML=Yo),go=s(K),P=l(K,"DIV",{class:!0});var ee=x(P);h(xe.$$.fragment,ee),ho=s(ee),Fe=l(ee,"P",{"data-svelte-h":!0}),p(Fe)!=="svelte-typ793"&&(Fe.textContent=Oo),fo=s(ee),h(F.$$.fragment,ee),_o=s(ee),h(Y.$$.fragment,ee),ee.forEach(t),K.forEach(t),Jt=s(e),G=l(e,"DIV",{class:!0});var Zt=x(G);h(Te.$$.fragment,Zt),vo=s(Zt),Ye=l(Zt,"P",{"data-svelte-h":!0}),p(Ye)!=="svelte-1caxwky"&&(Ye.textContent=Qo),Zt.forEach(t),zt=s(e),k=l(e,"DIV",{class:!0});var nt=x(k);h(Ie.$$.fragment,nt),bo=s(nt),Oe=l(nt,"P",{"data-svelte-h":!0}),p(Oe)!=="svelte-gpcvn9"&&(Oe.innerHTML=Ko),Mo=s(nt),Qe=l(nt,"P",{"data-svelte-h":!0}),p(Qe)!=="svelte-940nsl"&&(Qe.innerHTML=en),nt.forEach(t),kt=s(e),h($e.$$.fragment,e),Lt=s(e),st=l(e,"P",{}),x(st).forEach(t),this.h()},h(){T(c,"name","hf:doc:metadata"),T(c,"content",bn),T(U,"class","tip"),ft.a=_t,T(B,"class","tip"),T(A,"class","warning"),T(j,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),T(I,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),T(E,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),T(J,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),T(W,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),T($,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),T(H,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),T(z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),T(P,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),T(N,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),T(G,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),T(k,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8")},m(e,o){n(document.head,c),a(e,w,o),a(e,u,o),a(e,m,o),f(M,e,o),a(e,d,o),f(y,e,o),a(e,at,o),a(e,te,o),a(e,rt,o),a(e,oe,o),a(e,lt,o),a(e,ne,o),a(e,dt,o),a(e,U,o),a(e,ct,o),f(ie,e,o),a(e,pt,o),a(e,se,o),a(e,ut,o),a(e,ae,o),a(e,mt,o),f(re,e,o),a(e,gt,o),a(e,le,o),a(e,ht,o),a(e,V,o),n(V,qe),n(V,Rt),n(V,D),n(D,De),n(D,Ut),n(D,Je),n(D,Vt),n(D,ze),n(D,Bt),n(D,Z),n(Z,ke),n(Z,At),n(Z,Le),n(Z,St),n(Z,de),n(de,Xt),ft.m(nn,de),n(de,_t),a(e,vt,o),a(e,B,o),a(e,bt,o),a(e,A,o),a(e,Mt,o),a(e,ce,o),a(e,yt,o),f(pe,e,o),a(e,wt,o),a(e,I,o),f(ue,I,null),n(I,Ft),n(I,Ce),n(I,Yt),n(I,je),n(I,Ot),n(I,j),f(me,j,null),n(j,Qt),n(j,We),n(j,Kt),f(S,j,null),a(e,xt,o),a(e,E,o),f(ge,E,null),n(E,eo),n(E,Ze),a(e,Tt,o),a(e,J,o),f(he,J,null),n(J,to),n(J,Ee),n(J,oo),n(J,He),a(e,It,o),f(fe,e,o),a(e,$t,o),a(e,$,o),f(_e,$,null),n($,no),n($,Ge),n($,io),n($,Re),n($,so),n($,W),f(ve,W,null),n(W,ao),n(W,Ue),n(W,ro),f(X,W,null),a(e,Nt,o),a(e,H,o),f(be,H,null),n(H,lo),n(H,Ve),a(e,Pt,o),a(e,z,o),f(Me,z,null),n(z,co),n(z,Be),n(z,po),n(z,Ae),a(e,qt,o),f(ye,e,o),a(e,Dt,o),a(e,N,o),f(we,N,null),n(N,uo),n(N,Se),n(N,mo),n(N,Xe),n(N,go),n(N,P),f(xe,P,null),n(P,ho),n(P,Fe),n(P,fo),f(F,P,null),n(P,_o),f(Y,P,null),a(e,Jt,o),a(e,G,o),f(Te,G,null),n(G,vo),n(G,Ye),a(e,zt,o),a(e,k,o),f(Ie,k,null),n(k,bo),n(k,Oe),n(k,Mo),n(k,Qe),a(e,kt,o),f($e,e,o),a(e,Lt,o),a(e,st,o),Ct=!0},p(e,[o]){const Ne={};o&2&&(Ne.$$scope={dirty:o,ctx:e}),S.$set(Ne);const L={};o&2&&(L.$$scope={dirty:o,ctx:e}),X.$set(L);const R={};o&2&&(R.$$scope={dirty:o,ctx:e}),F.$set(R);const Pe={};o&2&&(Pe.$$scope={dirty:o,ctx:e}),Y.$set(Pe)},i(e){Ct||(_(M.$$.fragment,e),_(y.$$.fragment,e),_(ie.$$.fragment,e),_(re.$$.fragment,e),_(pe.$$.fragment,e),_(ue.$$.fragment,e),_(me.$$.fragment,e),_(S.$$.fragment,e),_(ge.$$.fragment,e),_(he.$$.fragment,e),_(fe.$$.fragment,e),_(_e.$$.fragment,e),_(ve.$$.fragment,e),_(X.$$.fragment,e),_(be.$$.fragment,e),_(Me.$$.fragment,e),_(ye.$$.fragment,e),_(we.$$.fragment,e),_(xe.$$.fragment,e),_(F.$$.fragment,e),_(Y.$$.fragment,e),_(Te.$$.fragment,e),_(Ie.$$.fragment,e),_($e.$$.fragment,e),Ct=!0)},o(e){v(M.$$.fragment,e),v(y.$$.fragment,e),v(ie.$$.fragment,e),v(re.$$.fragment,e),v(pe.$$.fragment,e),v(ue.$$.fragment,e),v(me.$$.fragment,e),v(S.$$.fragment,e),v(ge.$$.fragment,e),v(he.$$.fragment,e),v(fe.$$.fragment,e),v(_e.$$.fragment,e),v(ve.$$.fragment,e),v(X.$$.fragment,e),v(be.$$.fragment,e),v(Me.$$.fragment,e),v(ye.$$.fragment,e),v(we.$$.fragment,e),v(xe.$$.fragment,e),v(F.$$.fragment,e),v(Y.$$.fragment,e),v(Te.$$.fragment,e),v(Ie.$$.fragment,e),v($e.$$.fragment,e),Ct=!1},d(e){e&&(t(w),t(u),t(m),t(d),t(at),t(te),t(rt),t(oe),t(lt),t(ne),t(dt),t(U),t(ct),t(pt),t(se),t(ut),t(ae),t(mt),t(gt),t(le),t(ht),t(V),t(vt),t(B),t(bt),t(A),t(Mt),t(ce),t(yt),t(wt),t(I),t(xt),t(E),t(Tt),t(J),t(It),t($t),t($),t(Nt),t(H),t(Pt),t(z),t(qt),t(Dt),t(N),t(Jt),t(G),t(zt),t(k),t(kt),t(Lt),t(st)),t(c),b(M,e),b(y,e),b(ie,e),b(re,e),b(pe,e),b(ue),b(me),b(S),b(ge),b(he),b(fe,e),b(_e),b(ve),b(X),b(be),b(Me),b(ye,e),b(we),b(xe),b(F),b(Y),b(Te),b(Ie),b($e,e)}}}const bn='{"title":"Marigold Computer Vision","local":"marigold-computer-vision","sections":[{"title":"Available Pipelines","local":"available-pipelines","sections":[],"depth":2},{"title":"Available Checkpoints","local":"available-checkpoints","sections":[],"depth":2},{"title":"Marigold Depth Prediction API","local":"diffusers.MarigoldDepthPipeline","sections":[],"depth":2},{"title":"Marigold Normals Estimation API","local":"diffusers.MarigoldNormalsPipeline","sections":[],"depth":2},{"title":"Marigold Intrinsic Image Decomposition API","local":"diffusers.MarigoldIntrinsicsPipeline","sections":[],"depth":2}],"depth":1}';function Mn(C){return an(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class Pn extends rn{constructor(c){super(),ln(this,c,Mn,vn,sn,{})}}export{Pn as component}; | |
Xet Storage Details
- Size:
- 85.2 kB
- Xet hash:
- 1e11da3b9fb9ca451e6e2631b21f41c71db32a6a03fb623c48850f4f97ac5257
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.