diff --git a/app.py b/app.py index 5a6e52eb2d1e6d6eeeeb9146ddd1c6423bfe4573..4efe66972fd17ab8c511146eaf490b4d44f94805 100644 --- a/app.py +++ b/app.py @@ -17,7 +17,7 @@ from common import ( select_point, ) from gradio.themes import Default -from gradio.themes.utils.colors import slate, sky, blue, indigo +from gradio.themes.utils.colors import slate from gradio_litmodel3d import LitModel3D from asset3d_gen.models.delight import DelightingModel from asset3d_gen.models.segment import RembgRemover, SAMPredictor @@ -64,7 +64,7 @@ def end_session(req: gr.Request) -> None: with gr.Blocks( - delete_cache=(43200, 43200), theme=Default(primary_hue=indigo) + delete_cache=(43200, 43200), theme=Default(primary_hue=slate) ) as demo: gr.Markdown( f""" diff --git a/asset3d_gen/models/segment.py b/asset3d_gen/models/segment.py index a24ddd10c1bbe4f8cb4c8919a1798f036c615ad2..19144b66a30ae472bcf497bf36cbbd7a6663cbce 100644 --- a/asset3d_gen/models/segment.py +++ b/asset3d_gen/models/segment.py @@ -162,7 +162,7 @@ class SAMPredictor(object): checkpoint: str = None, model_type: str = "vit_h", binary_thresh: float = 0.1, - device: str = "cuda" + device: str = "cuda", ): self.device = device self.model_type = model_type diff --git a/asset3d_gen/utils/gpt_clients.py b/asset3d_gen/utils/gpt_clients.py index b2379129d16be8b36153fbddb5199a98862da616..b258f3b92c8db4180b80282185cc6b806309e02b 100644 --- a/asset3d_gen/utils/gpt_clients.py +++ b/asset3d_gen/utils/gpt_clients.py @@ -186,5 +186,7 @@ if __name__ == "__main__": print(response) # test2: text prompt - response = GPT_CLIENT.query(text_prompt="What is the capital of China?") + response = GPT_CLIENT.query( + text_prompt="What is the capital of China?" + ) print(response) diff --git a/common.py b/common.py index 8aad6329e51985b0c87e9f31469ab2e7f5a0d482..f11f7964762bb5b09267d8b1fa204613a26c991c 100644 --- a/common.py +++ b/common.py @@ -1,13 +1,14 @@ -import spaces import gc import logging import os import sys from glob import glob from typing import Union + import cv2 import gradio as gr import numpy as np +import spaces import torch import trimesh from easydict import EasyDict as edict @@ -44,8 +45,9 @@ from asset3d_gen.validators.quality_checkers import ( ) from asset3d_gen.validators.urdf_convertor import URDFGenerator, zip_files -current_directory = os.getcwd() -sys.path.insert(0, current_directory) +current_file_path = os.path.abspath(__file__) +current_dir = os.path.dirname(current_file_path) +sys.path.append(os.path.join(current_dir, "../..")) from thirdparty.TRELLIS.trellis.pipelines import TrellisImageTo3DPipeline from thirdparty.TRELLIS.trellis.renderers.mesh_renderer import MeshRenderer from thirdparty.TRELLIS.trellis.representations import ( diff --git a/requirements.txt b/requirements.txt index 5a89c33ac1e7d651ef963c7820529f2d7bdb2f90..06ba8e3ab5d39ab77d1228e07935d8e4b34ce9a0 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,6 @@ --extra-index-url https://download.pytorch.org/whl/cu118 + torch==2.1.0 torchaudio==2.1.0 torchvision==0.16.0 diff --git a/thirdparty/TRELLIS/trellis/__init__.py b/thirdparty/TRELLIS/trellis/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..20d240afc9c26a21aee76954628b3d4ef9a1ccbd --- /dev/null +++ b/thirdparty/TRELLIS/trellis/__init__.py @@ -0,0 +1,6 @@ +from . import models +from . import modules +from . import pipelines +from . import renderers +from . import representations +from . import utils diff --git a/thirdparty/TRELLIS/trellis/models/__init__.py b/thirdparty/TRELLIS/trellis/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d90e9f9ab48e7028a370a0df663182f4b8ccadc5 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/models/__init__.py @@ -0,0 +1,70 @@ +import importlib + +__attributes = { + 'SparseStructureEncoder': 'sparse_structure_vae', + 'SparseStructureDecoder': 'sparse_structure_vae', + 'SparseStructureFlowModel': 'sparse_structure_flow', + 'SLatEncoder': 'structured_latent_vae', + 'SLatGaussianDecoder': 'structured_latent_vae', + 'SLatRadianceFieldDecoder': 'structured_latent_vae', + 'SLatMeshDecoder': 'structured_latent_vae', + 'SLatFlowModel': 'structured_latent_flow', +} + +__submodules = [] + +__all__ = list(__attributes.keys()) + __submodules + +def __getattr__(name): + if name not in globals(): + if name in __attributes: + module_name = __attributes[name] + module = importlib.import_module(f".{module_name}", __name__) + globals()[name] = getattr(module, name) + elif name in __submodules: + module = importlib.import_module(f".{name}", __name__) + globals()[name] = module + else: + raise AttributeError(f"module {__name__} has no attribute {name}") + return globals()[name] + + +def from_pretrained(path: str, **kwargs): + """ + Load a model from a pretrained checkpoint. + + Args: + path: The path to the checkpoint. Can be either local path or a Hugging Face model name. + NOTE: config file and model file should take the name f'{path}.json' and f'{path}.safetensors' respectively. + **kwargs: Additional arguments for the model constructor. + """ + import os + import json + from safetensors.torch import load_file + is_local = os.path.exists(f"{path}.json") and os.path.exists(f"{path}.safetensors") + + if is_local: + config_file = f"{path}.json" + model_file = f"{path}.safetensors" + else: + from huggingface_hub import hf_hub_download + path_parts = path.split('/') + repo_id = f'{path_parts[0]}/{path_parts[1]}' + model_name = '/'.join(path_parts[2:]) + config_file = hf_hub_download(repo_id, f"{model_name}.json") + model_file = hf_hub_download(repo_id, f"{model_name}.safetensors") + + with open(config_file, 'r') as f: + config = json.load(f) + model = __getattr__(config['name'])(**config['args'], **kwargs) + model.load_state_dict(load_file(model_file)) + + return model + + +# For Pylance +if __name__ == '__main__': + from .sparse_structure_vae import SparseStructureEncoder, SparseStructureDecoder + from .sparse_structure_flow import SparseStructureFlowModel + from .structured_latent_vae import SLatEncoder, SLatGaussianDecoder, SLatRadianceFieldDecoder, SLatMeshDecoder + from .structured_latent_flow import SLatFlowModel diff --git a/thirdparty/TRELLIS/trellis/models/sparse_structure_flow.py b/thirdparty/TRELLIS/trellis/models/sparse_structure_flow.py new file mode 100644 index 0000000000000000000000000000000000000000..aee71a9686fd3795960cf1df970e9b8db0ebd57a --- /dev/null +++ b/thirdparty/TRELLIS/trellis/models/sparse_structure_flow.py @@ -0,0 +1,200 @@ +from typing import * +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +from ..modules.utils import convert_module_to_f16, convert_module_to_f32 +from ..modules.transformer import AbsolutePositionEmbedder, ModulatedTransformerCrossBlock +from ..modules.spatial import patchify, unpatchify + + +class TimestepEmbedder(nn.Module): + """ + Embeds scalar timesteps into vector representations. + """ + def __init__(self, hidden_size, frequency_embedding_size=256): + super().__init__() + self.mlp = nn.Sequential( + nn.Linear(frequency_embedding_size, hidden_size, bias=True), + nn.SiLU(), + nn.Linear(hidden_size, hidden_size, bias=True), + ) + self.frequency_embedding_size = frequency_embedding_size + + @staticmethod + def timestep_embedding(t, dim, max_period=10000): + """ + Create sinusoidal timestep embeddings. + + Args: + t: a 1-D Tensor of N indices, one per batch element. + These may be fractional. + dim: the dimension of the output. + max_period: controls the minimum frequency of the embeddings. + + Returns: + an (N, D) Tensor of positional embeddings. + """ + # https://github.com/openai/glide-text2im/blob/main/glide_text2im/nn.py + half = dim // 2 + freqs = torch.exp( + -np.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half + ).to(device=t.device) + args = t[:, None].float() * freqs[None] + embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1) + if dim % 2: + embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1) + return embedding + + def forward(self, t): + t_freq = self.timestep_embedding(t, self.frequency_embedding_size) + t_emb = self.mlp(t_freq) + return t_emb + + +class SparseStructureFlowModel(nn.Module): + def __init__( + self, + resolution: int, + in_channels: int, + model_channels: int, + cond_channels: int, + out_channels: int, + num_blocks: int, + num_heads: Optional[int] = None, + num_head_channels: Optional[int] = 64, + mlp_ratio: float = 4, + patch_size: int = 2, + pe_mode: Literal["ape", "rope"] = "ape", + use_fp16: bool = False, + use_checkpoint: bool = False, + share_mod: bool = False, + qk_rms_norm: bool = False, + qk_rms_norm_cross: bool = False, + ): + super().__init__() + self.resolution = resolution + self.in_channels = in_channels + self.model_channels = model_channels + self.cond_channels = cond_channels + self.out_channels = out_channels + self.num_blocks = num_blocks + self.num_heads = num_heads or model_channels // num_head_channels + self.mlp_ratio = mlp_ratio + self.patch_size = patch_size + self.pe_mode = pe_mode + self.use_fp16 = use_fp16 + self.use_checkpoint = use_checkpoint + self.share_mod = share_mod + self.qk_rms_norm = qk_rms_norm + self.qk_rms_norm_cross = qk_rms_norm_cross + self.dtype = torch.float16 if use_fp16 else torch.float32 + + self.t_embedder = TimestepEmbedder(model_channels) + if share_mod: + self.adaLN_modulation = nn.Sequential( + nn.SiLU(), + nn.Linear(model_channels, 6 * model_channels, bias=True) + ) + + if pe_mode == "ape": + pos_embedder = AbsolutePositionEmbedder(model_channels, 3) + coords = torch.meshgrid(*[torch.arange(res, device=self.device) for res in [resolution // patch_size] * 3], indexing='ij') + coords = torch.stack(coords, dim=-1).reshape(-1, 3) + pos_emb = pos_embedder(coords) + self.register_buffer("pos_emb", pos_emb) + + self.input_layer = nn.Linear(in_channels * patch_size**3, model_channels) + + self.blocks = nn.ModuleList([ + ModulatedTransformerCrossBlock( + model_channels, + cond_channels, + num_heads=self.num_heads, + mlp_ratio=self.mlp_ratio, + attn_mode='full', + use_checkpoint=self.use_checkpoint, + use_rope=(pe_mode == "rope"), + share_mod=share_mod, + qk_rms_norm=self.qk_rms_norm, + qk_rms_norm_cross=self.qk_rms_norm_cross, + ) + for _ in range(num_blocks) + ]) + + self.out_layer = nn.Linear(model_channels, out_channels * patch_size**3) + + self.initialize_weights() + if use_fp16: + self.convert_to_fp16() + + @property + def device(self) -> torch.device: + """ + Return the device of the model. + """ + return next(self.parameters()).device + + def convert_to_fp16(self) -> None: + """ + Convert the torso of the model to float16. + """ + self.blocks.apply(convert_module_to_f16) + + def convert_to_fp32(self) -> None: + """ + Convert the torso of the model to float32. + """ + self.blocks.apply(convert_module_to_f32) + + def initialize_weights(self) -> None: + # Initialize transformer layers: + def _basic_init(module): + if isinstance(module, nn.Linear): + torch.nn.init.xavier_uniform_(module.weight) + if module.bias is not None: + nn.init.constant_(module.bias, 0) + self.apply(_basic_init) + + # Initialize timestep embedding MLP: + nn.init.normal_(self.t_embedder.mlp[0].weight, std=0.02) + nn.init.normal_(self.t_embedder.mlp[2].weight, std=0.02) + + # Zero-out adaLN modulation layers in DiT blocks: + if self.share_mod: + nn.init.constant_(self.adaLN_modulation[-1].weight, 0) + nn.init.constant_(self.adaLN_modulation[-1].bias, 0) + else: + for block in self.blocks: + nn.init.constant_(block.adaLN_modulation[-1].weight, 0) + nn.init.constant_(block.adaLN_modulation[-1].bias, 0) + + # Zero-out output layers: + nn.init.constant_(self.out_layer.weight, 0) + nn.init.constant_(self.out_layer.bias, 0) + + def forward(self, x: torch.Tensor, t: torch.Tensor, cond: torch.Tensor) -> torch.Tensor: + assert [*x.shape] == [x.shape[0], self.in_channels, *[self.resolution] * 3], \ + f"Input shape mismatch, got {x.shape}, expected {[x.shape[0], self.in_channels, *[self.resolution] * 3]}" + + h = patchify(x, self.patch_size) + h = h.view(*h.shape[:2], -1).permute(0, 2, 1).contiguous() + + h = self.input_layer(h) + h = h + self.pos_emb[None] + t_emb = self.t_embedder(t) + if self.share_mod: + t_emb = self.adaLN_modulation(t_emb) + t_emb = t_emb.type(self.dtype) + h = h.type(self.dtype) + cond = cond.type(self.dtype) + for block in self.blocks: + h = block(h, t_emb, cond) + h = h.type(x.dtype) + h = F.layer_norm(h, h.shape[-1:]) + h = self.out_layer(h) + + h = h.permute(0, 2, 1).view(h.shape[0], h.shape[2], *[self.resolution // self.patch_size] * 3) + h = unpatchify(h, self.patch_size).contiguous() + + return h diff --git a/thirdparty/TRELLIS/trellis/models/sparse_structure_vae.py b/thirdparty/TRELLIS/trellis/models/sparse_structure_vae.py new file mode 100644 index 0000000000000000000000000000000000000000..c3e09136cf294c4c1b47b0f09fa6ee57bad2166d --- /dev/null +++ b/thirdparty/TRELLIS/trellis/models/sparse_structure_vae.py @@ -0,0 +1,306 @@ +from typing import * +import torch +import torch.nn as nn +import torch.nn.functional as F +from ..modules.norm import GroupNorm32, ChannelLayerNorm32 +from ..modules.spatial import pixel_shuffle_3d +from ..modules.utils import zero_module, convert_module_to_f16, convert_module_to_f32 + + +def norm_layer(norm_type: str, *args, **kwargs) -> nn.Module: + """ + Return a normalization layer. + """ + if norm_type == "group": + return GroupNorm32(32, *args, **kwargs) + elif norm_type == "layer": + return ChannelLayerNorm32(*args, **kwargs) + else: + raise ValueError(f"Invalid norm type {norm_type}") + + +class ResBlock3d(nn.Module): + def __init__( + self, + channels: int, + out_channels: Optional[int] = None, + norm_type: Literal["group", "layer"] = "layer", + ): + super().__init__() + self.channels = channels + self.out_channels = out_channels or channels + + self.norm1 = norm_layer(norm_type, channels) + self.norm2 = norm_layer(norm_type, self.out_channels) + self.conv1 = nn.Conv3d(channels, self.out_channels, 3, padding=1) + self.conv2 = zero_module(nn.Conv3d(self.out_channels, self.out_channels, 3, padding=1)) + self.skip_connection = nn.Conv3d(channels, self.out_channels, 1) if channels != self.out_channels else nn.Identity() + + def forward(self, x: torch.Tensor) -> torch.Tensor: + h = self.norm1(x) + h = F.silu(h) + h = self.conv1(h) + h = self.norm2(h) + h = F.silu(h) + h = self.conv2(h) + h = h + self.skip_connection(x) + return h + + +class DownsampleBlock3d(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + mode: Literal["conv", "avgpool"] = "conv", + ): + assert mode in ["conv", "avgpool"], f"Invalid mode {mode}" + + super().__init__() + self.in_channels = in_channels + self.out_channels = out_channels + + if mode == "conv": + self.conv = nn.Conv3d(in_channels, out_channels, 2, stride=2) + elif mode == "avgpool": + assert in_channels == out_channels, "Pooling mode requires in_channels to be equal to out_channels" + + def forward(self, x: torch.Tensor) -> torch.Tensor: + if hasattr(self, "conv"): + return self.conv(x) + else: + return F.avg_pool3d(x, 2) + + +class UpsampleBlock3d(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + mode: Literal["conv", "nearest"] = "conv", + ): + assert mode in ["conv", "nearest"], f"Invalid mode {mode}" + + super().__init__() + self.in_channels = in_channels + self.out_channels = out_channels + + if mode == "conv": + self.conv = nn.Conv3d(in_channels, out_channels*8, 3, padding=1) + elif mode == "nearest": + assert in_channels == out_channels, "Nearest mode requires in_channels to be equal to out_channels" + + def forward(self, x: torch.Tensor) -> torch.Tensor: + if hasattr(self, "conv"): + x = self.conv(x) + return pixel_shuffle_3d(x, 2) + else: + return F.interpolate(x, scale_factor=2, mode="nearest") + + +class SparseStructureEncoder(nn.Module): + """ + Encoder for Sparse Structure (\mathcal{E}_S in the paper Sec. 3.3). + + Args: + in_channels (int): Channels of the input. + latent_channels (int): Channels of the latent representation. + num_res_blocks (int): Number of residual blocks at each resolution. + channels (List[int]): Channels of the encoder blocks. + num_res_blocks_middle (int): Number of residual blocks in the middle. + norm_type (Literal["group", "layer"]): Type of normalization layer. + use_fp16 (bool): Whether to use FP16. + """ + def __init__( + self, + in_channels: int, + latent_channels: int, + num_res_blocks: int, + channels: List[int], + num_res_blocks_middle: int = 2, + norm_type: Literal["group", "layer"] = "layer", + use_fp16: bool = False, + ): + super().__init__() + self.in_channels = in_channels + self.latent_channels = latent_channels + self.num_res_blocks = num_res_blocks + self.channels = channels + self.num_res_blocks_middle = num_res_blocks_middle + self.norm_type = norm_type + self.use_fp16 = use_fp16 + self.dtype = torch.float16 if use_fp16 else torch.float32 + + self.input_layer = nn.Conv3d(in_channels, channels[0], 3, padding=1) + + self.blocks = nn.ModuleList([]) + for i, ch in enumerate(channels): + self.blocks.extend([ + ResBlock3d(ch, ch) + for _ in range(num_res_blocks) + ]) + if i < len(channels) - 1: + self.blocks.append( + DownsampleBlock3d(ch, channels[i+1]) + ) + + self.middle_block = nn.Sequential(*[ + ResBlock3d(channels[-1], channels[-1]) + for _ in range(num_res_blocks_middle) + ]) + + self.out_layer = nn.Sequential( + norm_layer(norm_type, channels[-1]), + nn.SiLU(), + nn.Conv3d(channels[-1], latent_channels*2, 3, padding=1) + ) + + if use_fp16: + self.convert_to_fp16() + + @property + def device(self) -> torch.device: + """ + Return the device of the model. + """ + return next(self.parameters()).device + + def convert_to_fp16(self) -> None: + """ + Convert the torso of the model to float16. + """ + self.use_fp16 = True + self.dtype = torch.float16 + self.blocks.apply(convert_module_to_f16) + self.middle_block.apply(convert_module_to_f16) + + def convert_to_fp32(self) -> None: + """ + Convert the torso of the model to float32. + """ + self.use_fp16 = False + self.dtype = torch.float32 + self.blocks.apply(convert_module_to_f32) + self.middle_block.apply(convert_module_to_f32) + + def forward(self, x: torch.Tensor, sample_posterior: bool = False, return_raw: bool = False) -> torch.Tensor: + h = self.input_layer(x) + h = h.type(self.dtype) + + for block in self.blocks: + h = block(h) + h = self.middle_block(h) + + h = h.type(x.dtype) + h = self.out_layer(h) + + mean, logvar = h.chunk(2, dim=1) + + if sample_posterior: + std = torch.exp(0.5 * logvar) + z = mean + std * torch.randn_like(std) + else: + z = mean + + if return_raw: + return z, mean, logvar + return z + + +class SparseStructureDecoder(nn.Module): + """ + Decoder for Sparse Structure (\mathcal{D}_S in the paper Sec. 3.3). + + Args: + out_channels (int): Channels of the output. + latent_channels (int): Channels of the latent representation. + num_res_blocks (int): Number of residual blocks at each resolution. + channels (List[int]): Channels of the decoder blocks. + num_res_blocks_middle (int): Number of residual blocks in the middle. + norm_type (Literal["group", "layer"]): Type of normalization layer. + use_fp16 (bool): Whether to use FP16. + """ + def __init__( + self, + out_channels: int, + latent_channels: int, + num_res_blocks: int, + channels: List[int], + num_res_blocks_middle: int = 2, + norm_type: Literal["group", "layer"] = "layer", + use_fp16: bool = False, + ): + super().__init__() + self.out_channels = out_channels + self.latent_channels = latent_channels + self.num_res_blocks = num_res_blocks + self.channels = channels + self.num_res_blocks_middle = num_res_blocks_middle + self.norm_type = norm_type + self.use_fp16 = use_fp16 + self.dtype = torch.float16 if use_fp16 else torch.float32 + + self.input_layer = nn.Conv3d(latent_channels, channels[0], 3, padding=1) + + self.middle_block = nn.Sequential(*[ + ResBlock3d(channels[0], channels[0]) + for _ in range(num_res_blocks_middle) + ]) + + self.blocks = nn.ModuleList([]) + for i, ch in enumerate(channels): + self.blocks.extend([ + ResBlock3d(ch, ch) + for _ in range(num_res_blocks) + ]) + if i < len(channels) - 1: + self.blocks.append( + UpsampleBlock3d(ch, channels[i+1]) + ) + + self.out_layer = nn.Sequential( + norm_layer(norm_type, channels[-1]), + nn.SiLU(), + nn.Conv3d(channels[-1], out_channels, 3, padding=1) + ) + + if use_fp16: + self.convert_to_fp16() + + @property + def device(self) -> torch.device: + """ + Return the device of the model. + """ + return next(self.parameters()).device + + def convert_to_fp16(self) -> None: + """ + Convert the torso of the model to float16. + """ + self.use_fp16 = True + self.dtype = torch.float16 + self.blocks.apply(convert_module_to_f16) + self.middle_block.apply(convert_module_to_f16) + + def convert_to_fp32(self) -> None: + """ + Convert the torso of the model to float32. + """ + self.use_fp16 = False + self.dtype = torch.float32 + self.blocks.apply(convert_module_to_f32) + self.middle_block.apply(convert_module_to_f32) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + h = self.input_layer(x) + + h = h.type(self.dtype) + + h = self.middle_block(h) + for block in self.blocks: + h = block(h) + + h = h.type(x.dtype) + h = self.out_layer(h) + return h diff --git a/thirdparty/TRELLIS/trellis/models/structured_latent_flow.py b/thirdparty/TRELLIS/trellis/models/structured_latent_flow.py new file mode 100644 index 0000000000000000000000000000000000000000..f1463d79bc472ce3ef6859a42e10a06de1f9ebf7 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/models/structured_latent_flow.py @@ -0,0 +1,262 @@ +from typing import * +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +from ..modules.utils import zero_module, convert_module_to_f16, convert_module_to_f32 +from ..modules.transformer import AbsolutePositionEmbedder +from ..modules.norm import LayerNorm32 +from ..modules import sparse as sp +from ..modules.sparse.transformer import ModulatedSparseTransformerCrossBlock +from .sparse_structure_flow import TimestepEmbedder + + +class SparseResBlock3d(nn.Module): + def __init__( + self, + channels: int, + emb_channels: int, + out_channels: Optional[int] = None, + downsample: bool = False, + upsample: bool = False, + ): + super().__init__() + self.channels = channels + self.emb_channels = emb_channels + self.out_channels = out_channels or channels + self.downsample = downsample + self.upsample = upsample + + assert not (downsample and upsample), "Cannot downsample and upsample at the same time" + + self.norm1 = LayerNorm32(channels, elementwise_affine=True, eps=1e-6) + self.norm2 = LayerNorm32(self.out_channels, elementwise_affine=False, eps=1e-6) + self.conv1 = sp.SparseConv3d(channels, self.out_channels, 3) + self.conv2 = zero_module(sp.SparseConv3d(self.out_channels, self.out_channels, 3)) + self.emb_layers = nn.Sequential( + nn.SiLU(), + nn.Linear(emb_channels, 2 * self.out_channels, bias=True), + ) + self.skip_connection = sp.SparseLinear(channels, self.out_channels) if channels != self.out_channels else nn.Identity() + self.updown = None + if self.downsample: + self.updown = sp.SparseDownsample(2) + elif self.upsample: + self.updown = sp.SparseUpsample(2) + + def _updown(self, x: sp.SparseTensor) -> sp.SparseTensor: + if self.updown is not None: + x = self.updown(x) + return x + + def forward(self, x: sp.SparseTensor, emb: torch.Tensor) -> sp.SparseTensor: + emb_out = self.emb_layers(emb).type(x.dtype) + scale, shift = torch.chunk(emb_out, 2, dim=1) + + x = self._updown(x) + h = x.replace(self.norm1(x.feats)) + h = h.replace(F.silu(h.feats)) + h = self.conv1(h) + h = h.replace(self.norm2(h.feats)) * (1 + scale) + shift + h = h.replace(F.silu(h.feats)) + h = self.conv2(h) + h = h + self.skip_connection(x) + + return h + + +class SLatFlowModel(nn.Module): + def __init__( + self, + resolution: int, + in_channels: int, + model_channels: int, + cond_channels: int, + out_channels: int, + num_blocks: int, + num_heads: Optional[int] = None, + num_head_channels: Optional[int] = 64, + mlp_ratio: float = 4, + patch_size: int = 2, + num_io_res_blocks: int = 2, + io_block_channels: List[int] = None, + pe_mode: Literal["ape", "rope"] = "ape", + use_fp16: bool = False, + use_checkpoint: bool = False, + use_skip_connection: bool = True, + share_mod: bool = False, + qk_rms_norm: bool = False, + qk_rms_norm_cross: bool = False, + ): + super().__init__() + self.resolution = resolution + self.in_channels = in_channels + self.model_channels = model_channels + self.cond_channels = cond_channels + self.out_channels = out_channels + self.num_blocks = num_blocks + self.num_heads = num_heads or model_channels // num_head_channels + self.mlp_ratio = mlp_ratio + self.patch_size = patch_size + self.num_io_res_blocks = num_io_res_blocks + self.io_block_channels = io_block_channels + self.pe_mode = pe_mode + self.use_fp16 = use_fp16 + self.use_checkpoint = use_checkpoint + self.use_skip_connection = use_skip_connection + self.share_mod = share_mod + self.qk_rms_norm = qk_rms_norm + self.qk_rms_norm_cross = qk_rms_norm_cross + self.dtype = torch.float16 if use_fp16 else torch.float32 + + assert int(np.log2(patch_size)) == np.log2(patch_size), "Patch size must be a power of 2" + assert np.log2(patch_size) == len(io_block_channels), "Number of IO ResBlocks must match the number of stages" + + self.t_embedder = TimestepEmbedder(model_channels) + if share_mod: + self.adaLN_modulation = nn.Sequential( + nn.SiLU(), + nn.Linear(model_channels, 6 * model_channels, bias=True) + ) + + if pe_mode == "ape": + self.pos_embedder = AbsolutePositionEmbedder(model_channels) + + self.input_layer = sp.SparseLinear(in_channels, io_block_channels[0]) + self.input_blocks = nn.ModuleList([]) + for chs, next_chs in zip(io_block_channels, io_block_channels[1:] + [model_channels]): + self.input_blocks.extend([ + SparseResBlock3d( + chs, + model_channels, + out_channels=chs, + ) + for _ in range(num_io_res_blocks-1) + ]) + self.input_blocks.append( + SparseResBlock3d( + chs, + model_channels, + out_channels=next_chs, + downsample=True, + ) + ) + + self.blocks = nn.ModuleList([ + ModulatedSparseTransformerCrossBlock( + model_channels, + cond_channels, + num_heads=self.num_heads, + mlp_ratio=self.mlp_ratio, + attn_mode='full', + use_checkpoint=self.use_checkpoint, + use_rope=(pe_mode == "rope"), + share_mod=self.share_mod, + qk_rms_norm=self.qk_rms_norm, + qk_rms_norm_cross=self.qk_rms_norm_cross, + ) + for _ in range(num_blocks) + ]) + + self.out_blocks = nn.ModuleList([]) + for chs, prev_chs in zip(reversed(io_block_channels), [model_channels] + list(reversed(io_block_channels[1:]))): + self.out_blocks.append( + SparseResBlock3d( + prev_chs * 2 if self.use_skip_connection else prev_chs, + model_channels, + out_channels=chs, + upsample=True, + ) + ) + self.out_blocks.extend([ + SparseResBlock3d( + chs * 2 if self.use_skip_connection else chs, + model_channels, + out_channels=chs, + ) + for _ in range(num_io_res_blocks-1) + ]) + self.out_layer = sp.SparseLinear(io_block_channels[0], out_channels) + + self.initialize_weights() + if use_fp16: + self.convert_to_fp16() + + @property + def device(self) -> torch.device: + """ + Return the device of the model. + """ + return next(self.parameters()).device + + def convert_to_fp16(self) -> None: + """ + Convert the torso of the model to float16. + """ + self.input_blocks.apply(convert_module_to_f16) + self.blocks.apply(convert_module_to_f16) + self.out_blocks.apply(convert_module_to_f16) + + def convert_to_fp32(self) -> None: + """ + Convert the torso of the model to float32. + """ + self.input_blocks.apply(convert_module_to_f32) + self.blocks.apply(convert_module_to_f32) + self.out_blocks.apply(convert_module_to_f32) + + def initialize_weights(self) -> None: + # Initialize transformer layers: + def _basic_init(module): + if isinstance(module, nn.Linear): + torch.nn.init.xavier_uniform_(module.weight) + if module.bias is not None: + nn.init.constant_(module.bias, 0) + self.apply(_basic_init) + + # Initialize timestep embedding MLP: + nn.init.normal_(self.t_embedder.mlp[0].weight, std=0.02) + nn.init.normal_(self.t_embedder.mlp[2].weight, std=0.02) + + # Zero-out adaLN modulation layers in DiT blocks: + if self.share_mod: + nn.init.constant_(self.adaLN_modulation[-1].weight, 0) + nn.init.constant_(self.adaLN_modulation[-1].bias, 0) + else: + for block in self.blocks: + nn.init.constant_(block.adaLN_modulation[-1].weight, 0) + nn.init.constant_(block.adaLN_modulation[-1].bias, 0) + + # Zero-out output layers: + nn.init.constant_(self.out_layer.weight, 0) + nn.init.constant_(self.out_layer.bias, 0) + + def forward(self, x: sp.SparseTensor, t: torch.Tensor, cond: torch.Tensor) -> sp.SparseTensor: + h = self.input_layer(x).type(self.dtype) + t_emb = self.t_embedder(t) + if self.share_mod: + t_emb = self.adaLN_modulation(t_emb) + t_emb = t_emb.type(self.dtype) + cond = cond.type(self.dtype) + + skips = [] + # pack with input blocks + for block in self.input_blocks: + h = block(h, t_emb) + skips.append(h.feats) + + if self.pe_mode == "ape": + h = h + self.pos_embedder(h.coords[:, 1:]).type(self.dtype) + for block in self.blocks: + h = block(h, t_emb, cond) + + # unpack with output blocks + for block, skip in zip(self.out_blocks, reversed(skips)): + if self.use_skip_connection: + h = block(h.replace(torch.cat([h.feats, skip], dim=1)), t_emb) + else: + h = block(h, t_emb) + + h = h.replace(F.layer_norm(h.feats, h.feats.shape[-1:])) + h = self.out_layer(h.type(x.dtype)) + return h diff --git a/thirdparty/TRELLIS/trellis/models/structured_latent_vae/__init__.py b/thirdparty/TRELLIS/trellis/models/structured_latent_vae/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75603bc1d86c3036972c3d740ca7cb93d872f836 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/models/structured_latent_vae/__init__.py @@ -0,0 +1,4 @@ +from .encoder import SLatEncoder +from .decoder_gs import SLatGaussianDecoder +from .decoder_rf import SLatRadianceFieldDecoder +from .decoder_mesh import SLatMeshDecoder diff --git a/thirdparty/TRELLIS/trellis/models/structured_latent_vae/base.py b/thirdparty/TRELLIS/trellis/models/structured_latent_vae/base.py new file mode 100644 index 0000000000000000000000000000000000000000..ab0bf6a850b1c146e081c32ad92c7c44ead5ef6e --- /dev/null +++ b/thirdparty/TRELLIS/trellis/models/structured_latent_vae/base.py @@ -0,0 +1,117 @@ +from typing import * +import torch +import torch.nn as nn +from ...modules.utils import convert_module_to_f16, convert_module_to_f32 +from ...modules import sparse as sp +from ...modules.transformer import AbsolutePositionEmbedder +from ...modules.sparse.transformer import SparseTransformerBlock + + +def block_attn_config(self): + """ + Return the attention configuration of the model. + """ + for i in range(self.num_blocks): + if self.attn_mode == "shift_window": + yield "serialized", self.window_size, 0, (16 * (i % 2),) * 3, sp.SerializeMode.Z_ORDER + elif self.attn_mode == "shift_sequence": + yield "serialized", self.window_size, self.window_size // 2 * (i % 2), (0, 0, 0), sp.SerializeMode.Z_ORDER + elif self.attn_mode == "shift_order": + yield "serialized", self.window_size, 0, (0, 0, 0), sp.SerializeModes[i % 4] + elif self.attn_mode == "full": + yield "full", None, None, None, None + elif self.attn_mode == "swin": + yield "windowed", self.window_size, None, self.window_size // 2 * (i % 2), None + + +class SparseTransformerBase(nn.Module): + """ + Sparse Transformer without output layers. + Serve as the base class for encoder and decoder. + """ + def __init__( + self, + in_channels: int, + model_channels: int, + num_blocks: int, + num_heads: Optional[int] = None, + num_head_channels: Optional[int] = 64, + mlp_ratio: float = 4.0, + attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full", + window_size: Optional[int] = None, + pe_mode: Literal["ape", "rope"] = "ape", + use_fp16: bool = False, + use_checkpoint: bool = False, + qk_rms_norm: bool = False, + ): + super().__init__() + self.in_channels = in_channels + self.model_channels = model_channels + self.num_blocks = num_blocks + self.window_size = window_size + self.num_heads = num_heads or model_channels // num_head_channels + self.mlp_ratio = mlp_ratio + self.attn_mode = attn_mode + self.pe_mode = pe_mode + self.use_fp16 = use_fp16 + self.use_checkpoint = use_checkpoint + self.qk_rms_norm = qk_rms_norm + self.dtype = torch.float16 if use_fp16 else torch.float32 + + if pe_mode == "ape": + self.pos_embedder = AbsolutePositionEmbedder(model_channels) + + self.input_layer = sp.SparseLinear(in_channels, model_channels) + self.blocks = nn.ModuleList([ + SparseTransformerBlock( + model_channels, + num_heads=self.num_heads, + mlp_ratio=self.mlp_ratio, + attn_mode=attn_mode, + window_size=window_size, + shift_sequence=shift_sequence, + shift_window=shift_window, + serialize_mode=serialize_mode, + use_checkpoint=self.use_checkpoint, + use_rope=(pe_mode == "rope"), + qk_rms_norm=self.qk_rms_norm, + ) + for attn_mode, window_size, shift_sequence, shift_window, serialize_mode in block_attn_config(self) + ]) + + @property + def device(self) -> torch.device: + """ + Return the device of the model. + """ + return next(self.parameters()).device + + def convert_to_fp16(self) -> None: + """ + Convert the torso of the model to float16. + """ + self.blocks.apply(convert_module_to_f16) + + def convert_to_fp32(self) -> None: + """ + Convert the torso of the model to float32. + """ + self.blocks.apply(convert_module_to_f32) + + def initialize_weights(self) -> None: + # Initialize transformer layers: + def _basic_init(module): + if isinstance(module, nn.Linear): + torch.nn.init.xavier_uniform_(module.weight) + if module.bias is not None: + nn.init.constant_(module.bias, 0) + self.apply(_basic_init) + + def forward(self, x: sp.SparseTensor) -> sp.SparseTensor: + h = self.input_layer(x) + if self.pe_mode == "ape": + h = h + self.pos_embedder(x.coords[:, 1:]) + h = h.type(self.dtype) + for block in self.blocks: + h = block(h) + return h diff --git a/thirdparty/TRELLIS/trellis/models/structured_latent_vae/decoder_gs.py b/thirdparty/TRELLIS/trellis/models/structured_latent_vae/decoder_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..b893cfcfb2a166c7d57f96086a79317bd91884b9 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/models/structured_latent_vae/decoder_gs.py @@ -0,0 +1,122 @@ +from typing import * +import torch +import torch.nn as nn +import torch.nn.functional as F +from ...modules import sparse as sp +from ...utils.random_utils import hammersley_sequence +from .base import SparseTransformerBase +from ...representations import Gaussian + + +class SLatGaussianDecoder(SparseTransformerBase): + def __init__( + self, + resolution: int, + model_channels: int, + latent_channels: int, + num_blocks: int, + num_heads: Optional[int] = None, + num_head_channels: Optional[int] = 64, + mlp_ratio: float = 4, + attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "swin", + window_size: int = 8, + pe_mode: Literal["ape", "rope"] = "ape", + use_fp16: bool = False, + use_checkpoint: bool = False, + qk_rms_norm: bool = False, + representation_config: dict = None, + ): + super().__init__( + in_channels=latent_channels, + model_channels=model_channels, + num_blocks=num_blocks, + num_heads=num_heads, + num_head_channels=num_head_channels, + mlp_ratio=mlp_ratio, + attn_mode=attn_mode, + window_size=window_size, + pe_mode=pe_mode, + use_fp16=use_fp16, + use_checkpoint=use_checkpoint, + qk_rms_norm=qk_rms_norm, + ) + self.resolution = resolution + self.rep_config = representation_config + self._calc_layout() + self.out_layer = sp.SparseLinear(model_channels, self.out_channels) + self._build_perturbation() + + self.initialize_weights() + if use_fp16: + self.convert_to_fp16() + + def initialize_weights(self) -> None: + super().initialize_weights() + # Zero-out output layers: + nn.init.constant_(self.out_layer.weight, 0) + nn.init.constant_(self.out_layer.bias, 0) + + def _build_perturbation(self) -> None: + perturbation = [hammersley_sequence(3, i, self.rep_config['num_gaussians']) for i in range(self.rep_config['num_gaussians'])] + perturbation = torch.tensor(perturbation).float() * 2 - 1 + perturbation = perturbation / self.rep_config['voxel_size'] + perturbation = torch.atanh(perturbation).to(self.device) + self.register_buffer('offset_perturbation', perturbation) + + def _calc_layout(self) -> None: + self.layout = { + '_xyz' : {'shape': (self.rep_config['num_gaussians'], 3), 'size': self.rep_config['num_gaussians'] * 3}, + '_features_dc' : {'shape': (self.rep_config['num_gaussians'], 1, 3), 'size': self.rep_config['num_gaussians'] * 3}, + '_scaling' : {'shape': (self.rep_config['num_gaussians'], 3), 'size': self.rep_config['num_gaussians'] * 3}, + '_rotation' : {'shape': (self.rep_config['num_gaussians'], 4), 'size': self.rep_config['num_gaussians'] * 4}, + '_opacity' : {'shape': (self.rep_config['num_gaussians'], 1), 'size': self.rep_config['num_gaussians']}, + } + start = 0 + for k, v in self.layout.items(): + v['range'] = (start, start + v['size']) + start += v['size'] + self.out_channels = start + + def to_representation(self, x: sp.SparseTensor) -> List[Gaussian]: + """ + Convert a batch of network outputs to 3D representations. + + Args: + x: The [N x * x C] sparse tensor output by the network. + + Returns: + list of representations + """ + ret = [] + for i in range(x.shape[0]): + representation = Gaussian( + sh_degree=0, + aabb=[-0.5, -0.5, -0.5, 1.0, 1.0, 1.0], + mininum_kernel_size = self.rep_config['3d_filter_kernel_size'], + scaling_bias = self.rep_config['scaling_bias'], + opacity_bias = self.rep_config['opacity_bias'], + scaling_activation = self.rep_config['scaling_activation'] + ) + xyz = (x.coords[x.layout[i]][:, 1:].float() + 0.5) / self.resolution + for k, v in self.layout.items(): + if k == '_xyz': + offset = x.feats[x.layout[i]][:, v['range'][0]:v['range'][1]].reshape(-1, *v['shape']) + offset = offset * self.rep_config['lr'][k] + if self.rep_config['perturb_offset']: + offset = offset + self.offset_perturbation + offset = torch.tanh(offset) / self.resolution * 0.5 * self.rep_config['voxel_size'] + _xyz = xyz.unsqueeze(1) + offset + setattr(representation, k, _xyz.flatten(0, 1)) + else: + feats = x.feats[x.layout[i]][:, v['range'][0]:v['range'][1]].reshape(-1, *v['shape']).flatten(0, 1) + feats = feats * self.rep_config['lr'][k] + setattr(representation, k, feats) + ret.append(representation) + return ret + + def forward(self, x: sp.SparseTensor) -> List[Gaussian]: + h = super().forward(x) + h = h.type(x.dtype) + h = h.replace(F.layer_norm(h.feats, h.feats.shape[-1:])) + h = self.out_layer(h) + return self.to_representation(h) diff --git a/thirdparty/TRELLIS/trellis/models/structured_latent_vae/decoder_mesh.py b/thirdparty/TRELLIS/trellis/models/structured_latent_vae/decoder_mesh.py new file mode 100644 index 0000000000000000000000000000000000000000..75c1b1ec7b6fdc28e787be283e55589b36461e50 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/models/structured_latent_vae/decoder_mesh.py @@ -0,0 +1,167 @@ +from typing import * +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +from ...modules.utils import zero_module, convert_module_to_f16, convert_module_to_f32 +from ...modules import sparse as sp +from .base import SparseTransformerBase +from ...representations import MeshExtractResult +from ...representations.mesh import SparseFeatures2Mesh + + +class SparseSubdivideBlock3d(nn.Module): + """ + A 3D subdivide block that can subdivide the sparse tensor. + + Args: + channels: channels in the inputs and outputs. + out_channels: if specified, the number of output channels. + num_groups: the number of groups for the group norm. + """ + def __init__( + self, + channels: int, + resolution: int, + out_channels: Optional[int] = None, + num_groups: int = 32 + ): + super().__init__() + self.channels = channels + self.resolution = resolution + self.out_resolution = resolution * 2 + self.out_channels = out_channels or channels + + self.act_layers = nn.Sequential( + sp.SparseGroupNorm32(num_groups, channels), + sp.SparseSiLU() + ) + + self.sub = sp.SparseSubdivide() + + self.out_layers = nn.Sequential( + sp.SparseConv3d(channels, self.out_channels, 3, indice_key=f"res_{self.out_resolution}"), + sp.SparseGroupNorm32(num_groups, self.out_channels), + sp.SparseSiLU(), + zero_module(sp.SparseConv3d(self.out_channels, self.out_channels, 3, indice_key=f"res_{self.out_resolution}")), + ) + + if self.out_channels == channels: + self.skip_connection = nn.Identity() + else: + self.skip_connection = sp.SparseConv3d(channels, self.out_channels, 1, indice_key=f"res_{self.out_resolution}") + + def forward(self, x: sp.SparseTensor) -> sp.SparseTensor: + """ + Apply the block to a Tensor, conditioned on a timestep embedding. + + Args: + x: an [N x C x ...] Tensor of features. + Returns: + an [N x C x ...] Tensor of outputs. + """ + h = self.act_layers(x) + h = self.sub(h) + x = self.sub(x) + h = self.out_layers(h) + h = h + self.skip_connection(x) + return h + + +class SLatMeshDecoder(SparseTransformerBase): + def __init__( + self, + resolution: int, + model_channels: int, + latent_channels: int, + num_blocks: int, + num_heads: Optional[int] = None, + num_head_channels: Optional[int] = 64, + mlp_ratio: float = 4, + attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "swin", + window_size: int = 8, + pe_mode: Literal["ape", "rope"] = "ape", + use_fp16: bool = False, + use_checkpoint: bool = False, + qk_rms_norm: bool = False, + representation_config: dict = None, + ): + super().__init__( + in_channels=latent_channels, + model_channels=model_channels, + num_blocks=num_blocks, + num_heads=num_heads, + num_head_channels=num_head_channels, + mlp_ratio=mlp_ratio, + attn_mode=attn_mode, + window_size=window_size, + pe_mode=pe_mode, + use_fp16=use_fp16, + use_checkpoint=use_checkpoint, + qk_rms_norm=qk_rms_norm, + ) + self.resolution = resolution + self.rep_config = representation_config + self.mesh_extractor = SparseFeatures2Mesh(res=self.resolution*4, use_color=self.rep_config.get('use_color', False)) + self.out_channels = self.mesh_extractor.feats_channels + self.upsample = nn.ModuleList([ + SparseSubdivideBlock3d( + channels=model_channels, + resolution=resolution, + out_channels=model_channels // 4 + ), + SparseSubdivideBlock3d( + channels=model_channels // 4, + resolution=resolution * 2, + out_channels=model_channels // 8 + ) + ]) + self.out_layer = sp.SparseLinear(model_channels // 8, self.out_channels) + + self.initialize_weights() + if use_fp16: + self.convert_to_fp16() + + def initialize_weights(self) -> None: + super().initialize_weights() + # Zero-out output layers: + nn.init.constant_(self.out_layer.weight, 0) + nn.init.constant_(self.out_layer.bias, 0) + + def convert_to_fp16(self) -> None: + """ + Convert the torso of the model to float16. + """ + super().convert_to_fp16() + self.upsample.apply(convert_module_to_f16) + + def convert_to_fp32(self) -> None: + """ + Convert the torso of the model to float32. + """ + super().convert_to_fp32() + self.upsample.apply(convert_module_to_f32) + + def to_representation(self, x: sp.SparseTensor) -> List[MeshExtractResult]: + """ + Convert a batch of network outputs to 3D representations. + + Args: + x: The [N x * x C] sparse tensor output by the network. + + Returns: + list of representations + """ + ret = [] + for i in range(x.shape[0]): + mesh = self.mesh_extractor(x[i], training=self.training) + ret.append(mesh) + return ret + + def forward(self, x: sp.SparseTensor) -> List[MeshExtractResult]: + h = super().forward(x) + for block in self.upsample: + h = block(h) + h = h.type(x.dtype) + h = self.out_layer(h) + return self.to_representation(h) diff --git a/thirdparty/TRELLIS/trellis/models/structured_latent_vae/decoder_rf.py b/thirdparty/TRELLIS/trellis/models/structured_latent_vae/decoder_rf.py new file mode 100644 index 0000000000000000000000000000000000000000..968bb30596647224292da0392dfdefeed49d214d --- /dev/null +++ b/thirdparty/TRELLIS/trellis/models/structured_latent_vae/decoder_rf.py @@ -0,0 +1,104 @@ +from typing import * +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +from ...modules import sparse as sp +from .base import SparseTransformerBase +from ...representations import Strivec + + +class SLatRadianceFieldDecoder(SparseTransformerBase): + def __init__( + self, + resolution: int, + model_channels: int, + latent_channels: int, + num_blocks: int, + num_heads: Optional[int] = None, + num_head_channels: Optional[int] = 64, + mlp_ratio: float = 4, + attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "swin", + window_size: int = 8, + pe_mode: Literal["ape", "rope"] = "ape", + use_fp16: bool = False, + use_checkpoint: bool = False, + qk_rms_norm: bool = False, + representation_config: dict = None, + ): + super().__init__( + in_channels=latent_channels, + model_channels=model_channels, + num_blocks=num_blocks, + num_heads=num_heads, + num_head_channels=num_head_channels, + mlp_ratio=mlp_ratio, + attn_mode=attn_mode, + window_size=window_size, + pe_mode=pe_mode, + use_fp16=use_fp16, + use_checkpoint=use_checkpoint, + qk_rms_norm=qk_rms_norm, + ) + self.resolution = resolution + self.rep_config = representation_config + self._calc_layout() + self.out_layer = sp.SparseLinear(model_channels, self.out_channels) + + self.initialize_weights() + if use_fp16: + self.convert_to_fp16() + + def initialize_weights(self) -> None: + super().initialize_weights() + # Zero-out output layers: + nn.init.constant_(self.out_layer.weight, 0) + nn.init.constant_(self.out_layer.bias, 0) + + def _calc_layout(self) -> None: + self.layout = { + 'trivec': {'shape': (self.rep_config['rank'], 3, self.rep_config['dim']), 'size': self.rep_config['rank'] * 3 * self.rep_config['dim']}, + 'density': {'shape': (self.rep_config['rank'],), 'size': self.rep_config['rank']}, + 'features_dc': {'shape': (self.rep_config['rank'], 1, 3), 'size': self.rep_config['rank'] * 3}, + } + start = 0 + for k, v in self.layout.items(): + v['range'] = (start, start + v['size']) + start += v['size'] + self.out_channels = start + + def to_representation(self, x: sp.SparseTensor) -> List[Strivec]: + """ + Convert a batch of network outputs to 3D representations. + + Args: + x: The [N x * x C] sparse tensor output by the network. + + Returns: + list of representations + """ + ret = [] + for i in range(x.shape[0]): + representation = Strivec( + sh_degree=0, + resolution=self.resolution, + aabb=[-0.5, -0.5, -0.5, 1, 1, 1], + rank=self.rep_config['rank'], + dim=self.rep_config['dim'], + device='cuda', + ) + representation.density_shift = 0.0 + representation.position = (x.coords[x.layout[i]][:, 1:].float() + 0.5) / self.resolution + representation.depth = torch.full((representation.position.shape[0], 1), int(np.log2(self.resolution)), dtype=torch.uint8, device='cuda') + for k, v in self.layout.items(): + setattr(representation, k, x.feats[x.layout[i]][:, v['range'][0]:v['range'][1]].reshape(-1, *v['shape'])) + representation.trivec = representation.trivec + 1 + ret.append(representation) + return ret + + def forward(self, x: sp.SparseTensor) -> List[Strivec]: + h = super().forward(x) + h = h.type(x.dtype) + h = h.replace(F.layer_norm(h.feats, h.feats.shape[-1:])) + h = self.out_layer(h) + return self.to_representation(h) diff --git a/thirdparty/TRELLIS/trellis/models/structured_latent_vae/encoder.py b/thirdparty/TRELLIS/trellis/models/structured_latent_vae/encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..8370921d8d61954b43dcf3e251b8d9b315f4f536 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/models/structured_latent_vae/encoder.py @@ -0,0 +1,72 @@ +from typing import * +import torch +import torch.nn as nn +import torch.nn.functional as F +from ...modules import sparse as sp +from .base import SparseTransformerBase + + +class SLatEncoder(SparseTransformerBase): + def __init__( + self, + resolution: int, + in_channels: int, + model_channels: int, + latent_channels: int, + num_blocks: int, + num_heads: Optional[int] = None, + num_head_channels: Optional[int] = 64, + mlp_ratio: float = 4, + attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "swin", + window_size: int = 8, + pe_mode: Literal["ape", "rope"] = "ape", + use_fp16: bool = False, + use_checkpoint: bool = False, + qk_rms_norm: bool = False, + ): + super().__init__( + in_channels=in_channels, + model_channels=model_channels, + num_blocks=num_blocks, + num_heads=num_heads, + num_head_channels=num_head_channels, + mlp_ratio=mlp_ratio, + attn_mode=attn_mode, + window_size=window_size, + pe_mode=pe_mode, + use_fp16=use_fp16, + use_checkpoint=use_checkpoint, + qk_rms_norm=qk_rms_norm, + ) + self.resolution = resolution + self.out_layer = sp.SparseLinear(model_channels, 2 * latent_channels) + + self.initialize_weights() + if use_fp16: + self.convert_to_fp16() + + def initialize_weights(self) -> None: + super().initialize_weights() + # Zero-out output layers: + nn.init.constant_(self.out_layer.weight, 0) + nn.init.constant_(self.out_layer.bias, 0) + + def forward(self, x: sp.SparseTensor, sample_posterior=True, return_raw=False): + h = super().forward(x) + h = h.type(x.dtype) + h = h.replace(F.layer_norm(h.feats, h.feats.shape[-1:])) + h = self.out_layer(h) + + # Sample from the posterior distribution + mean, logvar = h.feats.chunk(2, dim=-1) + if sample_posterior: + std = torch.exp(0.5 * logvar) + z = mean + std * torch.randn_like(std) + else: + z = mean + z = h.replace(z) + + if return_raw: + return z, mean, logvar + else: + return z diff --git a/thirdparty/TRELLIS/trellis/modules/attention/__init__.py b/thirdparty/TRELLIS/trellis/modules/attention/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..f452320d5dbc4c0aa1664e33f76c56ff4bbe2039 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/attention/__init__.py @@ -0,0 +1,36 @@ +from typing import * + +BACKEND = 'flash_attn' +DEBUG = False + +def __from_env(): + import os + + global BACKEND + global DEBUG + + env_attn_backend = os.environ.get('ATTN_BACKEND') + env_sttn_debug = os.environ.get('ATTN_DEBUG') + + if env_attn_backend is not None and env_attn_backend in ['xformers', 'flash_attn', 'sdpa', 'naive']: + BACKEND = env_attn_backend + if env_sttn_debug is not None: + DEBUG = env_sttn_debug == '1' + + print(f"[ATTENTION] Using backend: {BACKEND}") + + +__from_env() + + +def set_backend(backend: Literal['xformers', 'flash_attn']): + global BACKEND + BACKEND = backend + +def set_debug(debug: bool): + global DEBUG + DEBUG = debug + + +from .full_attn import * +from .modules import * diff --git a/thirdparty/TRELLIS/trellis/modules/attention/full_attn.py b/thirdparty/TRELLIS/trellis/modules/attention/full_attn.py new file mode 100755 index 0000000000000000000000000000000000000000..d9ebf6380a78906d4c6e969c63223fb7b398e5a7 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/attention/full_attn.py @@ -0,0 +1,140 @@ +from typing import * +import torch +import math +from . import DEBUG, BACKEND + +if BACKEND == 'xformers': + import xformers.ops as xops +elif BACKEND == 'flash_attn': + import flash_attn +elif BACKEND == 'sdpa': + from torch.nn.functional import scaled_dot_product_attention as sdpa +elif BACKEND == 'naive': + pass +else: + raise ValueError(f"Unknown attention backend: {BACKEND}") + + +__all__ = [ + 'scaled_dot_product_attention', +] + + +def _naive_sdpa(q, k, v): + """ + Naive implementation of scaled dot product attention. + """ + q = q.permute(0, 2, 1, 3) # [N, H, L, C] + k = k.permute(0, 2, 1, 3) # [N, H, L, C] + v = v.permute(0, 2, 1, 3) # [N, H, L, C] + scale_factor = 1 / math.sqrt(q.size(-1)) + attn_weight = q @ k.transpose(-2, -1) * scale_factor + attn_weight = torch.softmax(attn_weight, dim=-1) + out = attn_weight @ v + out = out.permute(0, 2, 1, 3) # [N, L, H, C] + return out + + +@overload +def scaled_dot_product_attention(qkv: torch.Tensor) -> torch.Tensor: + """ + Apply scaled dot product attention. + + Args: + qkv (torch.Tensor): A [N, L, 3, H, C] tensor containing Qs, Ks, and Vs. + """ + ... + +@overload +def scaled_dot_product_attention(q: torch.Tensor, kv: torch.Tensor) -> torch.Tensor: + """ + Apply scaled dot product attention. + + Args: + q (torch.Tensor): A [N, L, H, C] tensor containing Qs. + kv (torch.Tensor): A [N, L, 2, H, C] tensor containing Ks and Vs. + """ + ... + +@overload +def scaled_dot_product_attention(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor) -> torch.Tensor: + """ + Apply scaled dot product attention. + + Args: + q (torch.Tensor): A [N, L, H, Ci] tensor containing Qs. + k (torch.Tensor): A [N, L, H, Ci] tensor containing Ks. + v (torch.Tensor): A [N, L, H, Co] tensor containing Vs. + + Note: + k and v are assumed to have the same coordinate map. + """ + ... + +def scaled_dot_product_attention(*args, **kwargs): + arg_names_dict = { + 1: ['qkv'], + 2: ['q', 'kv'], + 3: ['q', 'k', 'v'] + } + num_all_args = len(args) + len(kwargs) + assert num_all_args in arg_names_dict, f"Invalid number of arguments, got {num_all_args}, expected 1, 2, or 3" + for key in arg_names_dict[num_all_args][len(args):]: + assert key in kwargs, f"Missing argument {key}" + + if num_all_args == 1: + qkv = args[0] if len(args) > 0 else kwargs['qkv'] + assert len(qkv.shape) == 5 and qkv.shape[2] == 3, f"Invalid shape for qkv, got {qkv.shape}, expected [N, L, 3, H, C]" + device = qkv.device + + elif num_all_args == 2: + q = args[0] if len(args) > 0 else kwargs['q'] + kv = args[1] if len(args) > 1 else kwargs['kv'] + assert q.shape[0] == kv.shape[0], f"Batch size mismatch, got {q.shape[0]} and {kv.shape[0]}" + assert len(q.shape) == 4, f"Invalid shape for q, got {q.shape}, expected [N, L, H, C]" + assert len(kv.shape) == 5, f"Invalid shape for kv, got {kv.shape}, expected [N, L, 2, H, C]" + device = q.device + + elif num_all_args == 3: + q = args[0] if len(args) > 0 else kwargs['q'] + k = args[1] if len(args) > 1 else kwargs['k'] + v = args[2] if len(args) > 2 else kwargs['v'] + assert q.shape[0] == k.shape[0] == v.shape[0], f"Batch size mismatch, got {q.shape[0]}, {k.shape[0]}, and {v.shape[0]}" + assert len(q.shape) == 4, f"Invalid shape for q, got {q.shape}, expected [N, L, H, Ci]" + assert len(k.shape) == 4, f"Invalid shape for k, got {k.shape}, expected [N, L, H, Ci]" + assert len(v.shape) == 4, f"Invalid shape for v, got {v.shape}, expected [N, L, H, Co]" + device = q.device + + if BACKEND == 'xformers': + if num_all_args == 1: + q, k, v = qkv.unbind(dim=2) + elif num_all_args == 2: + k, v = kv.unbind(dim=2) + out = xops.memory_efficient_attention(q, k, v) + elif BACKEND == 'flash_attn': + if num_all_args == 1: + out = flash_attn.flash_attn_qkvpacked_func(qkv) + elif num_all_args == 2: + out = flash_attn.flash_attn_kvpacked_func(q, kv) + elif num_all_args == 3: + out = flash_attn.flash_attn_func(q, k, v) + elif BACKEND == 'sdpa': + if num_all_args == 1: + q, k, v = qkv.unbind(dim=2) + elif num_all_args == 2: + k, v = kv.unbind(dim=2) + q = q.permute(0, 2, 1, 3) # [N, H, L, C] + k = k.permute(0, 2, 1, 3) # [N, H, L, C] + v = v.permute(0, 2, 1, 3) # [N, H, L, C] + out = sdpa(q, k, v) # [N, H, L, C] + out = out.permute(0, 2, 1, 3) # [N, L, H, C] + elif BACKEND == 'naive': + if num_all_args == 1: + q, k, v = qkv.unbind(dim=2) + elif num_all_args == 2: + k, v = kv.unbind(dim=2) + out = _naive_sdpa(q, k, v) + else: + raise ValueError(f"Unknown attention module: {BACKEND}") + + return out diff --git a/thirdparty/TRELLIS/trellis/modules/attention/modules.py b/thirdparty/TRELLIS/trellis/modules/attention/modules.py new file mode 100755 index 0000000000000000000000000000000000000000..dbe6235c27134f0477e48d3e12de3068c6a500ef --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/attention/modules.py @@ -0,0 +1,146 @@ +from typing import * +import torch +import torch.nn as nn +import torch.nn.functional as F +from .full_attn import scaled_dot_product_attention + + +class MultiHeadRMSNorm(nn.Module): + def __init__(self, dim: int, heads: int): + super().__init__() + self.scale = dim ** 0.5 + self.gamma = nn.Parameter(torch.ones(heads, dim)) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return (F.normalize(x.float(), dim = -1) * self.gamma * self.scale).to(x.dtype) + + +class RotaryPositionEmbedder(nn.Module): + def __init__(self, hidden_size: int, in_channels: int = 3): + super().__init__() + assert hidden_size % 2 == 0, "Hidden size must be divisible by 2" + self.hidden_size = hidden_size + self.in_channels = in_channels + self.freq_dim = hidden_size // in_channels // 2 + self.freqs = torch.arange(self.freq_dim, dtype=torch.float32) / self.freq_dim + self.freqs = 1.0 / (10000 ** self.freqs) + + def _get_phases(self, indices: torch.Tensor) -> torch.Tensor: + self.freqs = self.freqs.to(indices.device) + phases = torch.outer(indices, self.freqs) + phases = torch.polar(torch.ones_like(phases), phases) + return phases + + def _rotary_embedding(self, x: torch.Tensor, phases: torch.Tensor) -> torch.Tensor: + x_complex = torch.view_as_complex(x.float().reshape(*x.shape[:-1], -1, 2)) + x_rotated = x_complex * phases + x_embed = torch.view_as_real(x_rotated).reshape(*x_rotated.shape[:-1], -1).to(x.dtype) + return x_embed + + def forward(self, q: torch.Tensor, k: torch.Tensor, indices: Optional[torch.Tensor] = None) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Args: + q (sp.SparseTensor): [..., N, D] tensor of queries + k (sp.SparseTensor): [..., N, D] tensor of keys + indices (torch.Tensor): [..., N, C] tensor of spatial positions + """ + if indices is None: + indices = torch.arange(q.shape[-2], device=q.device) + if len(q.shape) > 2: + indices = indices.unsqueeze(0).expand(q.shape[:-2] + (-1,)) + + phases = self._get_phases(indices.reshape(-1)).reshape(*indices.shape[:-1], -1) + if phases.shape[1] < self.hidden_size // 2: + phases = torch.cat([phases, torch.polar( + torch.ones(*phases.shape[:-1], self.hidden_size // 2 - phases.shape[1], device=phases.device), + torch.zeros(*phases.shape[:-1], self.hidden_size // 2 - phases.shape[1], device=phases.device) + )], dim=-1) + q_embed = self._rotary_embedding(q, phases) + k_embed = self._rotary_embedding(k, phases) + return q_embed, k_embed + + +class MultiHeadAttention(nn.Module): + def __init__( + self, + channels: int, + num_heads: int, + ctx_channels: Optional[int]=None, + type: Literal["self", "cross"] = "self", + attn_mode: Literal["full", "windowed"] = "full", + window_size: Optional[int] = None, + shift_window: Optional[Tuple[int, int, int]] = None, + qkv_bias: bool = True, + use_rope: bool = False, + qk_rms_norm: bool = False, + ): + super().__init__() + assert channels % num_heads == 0 + assert type in ["self", "cross"], f"Invalid attention type: {type}" + assert attn_mode in ["full", "windowed"], f"Invalid attention mode: {attn_mode}" + assert type == "self" or attn_mode == "full", "Cross-attention only supports full attention" + + if attn_mode == "windowed": + raise NotImplementedError("Windowed attention is not yet implemented") + + self.channels = channels + self.head_dim = channels // num_heads + self.ctx_channels = ctx_channels if ctx_channels is not None else channels + self.num_heads = num_heads + self._type = type + self.attn_mode = attn_mode + self.window_size = window_size + self.shift_window = shift_window + self.use_rope = use_rope + self.qk_rms_norm = qk_rms_norm + + if self._type == "self": + self.to_qkv = nn.Linear(channels, channels * 3, bias=qkv_bias) + else: + self.to_q = nn.Linear(channels, channels, bias=qkv_bias) + self.to_kv = nn.Linear(self.ctx_channels, channels * 2, bias=qkv_bias) + + if self.qk_rms_norm: + self.q_rms_norm = MultiHeadRMSNorm(self.head_dim, num_heads) + self.k_rms_norm = MultiHeadRMSNorm(self.head_dim, num_heads) + + self.to_out = nn.Linear(channels, channels) + + if use_rope: + self.rope = RotaryPositionEmbedder(channels) + + def forward(self, x: torch.Tensor, context: Optional[torch.Tensor] = None, indices: Optional[torch.Tensor] = None) -> torch.Tensor: + B, L, C = x.shape + if self._type == "self": + qkv = self.to_qkv(x) + qkv = qkv.reshape(B, L, 3, self.num_heads, -1) + if self.use_rope: + q, k, v = qkv.unbind(dim=2) + q, k = self.rope(q, k, indices) + qkv = torch.stack([q, k, v], dim=2) + if self.attn_mode == "full": + if self.qk_rms_norm: + q, k, v = qkv.unbind(dim=2) + q = self.q_rms_norm(q) + k = self.k_rms_norm(k) + h = scaled_dot_product_attention(q, k, v) + else: + h = scaled_dot_product_attention(qkv) + elif self.attn_mode == "windowed": + raise NotImplementedError("Windowed attention is not yet implemented") + else: + Lkv = context.shape[1] + q = self.to_q(x) + kv = self.to_kv(context) + q = q.reshape(B, L, self.num_heads, -1) + kv = kv.reshape(B, Lkv, 2, self.num_heads, -1) + if self.qk_rms_norm: + q = self.q_rms_norm(q) + k, v = kv.unbind(dim=2) + k = self.k_rms_norm(k) + h = scaled_dot_product_attention(q, k, v) + else: + h = scaled_dot_product_attention(q, kv) + h = h.reshape(B, L, -1) + h = self.to_out(h) + return h diff --git a/thirdparty/TRELLIS/trellis/modules/norm.py b/thirdparty/TRELLIS/trellis/modules/norm.py new file mode 100644 index 0000000000000000000000000000000000000000..09035726081fb7afda2c62504d5474cfa483c58f --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/norm.py @@ -0,0 +1,25 @@ +import torch +import torch.nn as nn + + +class LayerNorm32(nn.LayerNorm): + def forward(self, x: torch.Tensor) -> torch.Tensor: + return super().forward(x.float()).type(x.dtype) + + +class GroupNorm32(nn.GroupNorm): + """ + A GroupNorm layer that converts to float32 before the forward pass. + """ + def forward(self, x: torch.Tensor) -> torch.Tensor: + return super().forward(x.float()).type(x.dtype) + + +class ChannelLayerNorm32(LayerNorm32): + def forward(self, x: torch.Tensor) -> torch.Tensor: + DIM = x.dim() + x = x.permute(0, *range(2, DIM), 1).contiguous() + x = super().forward(x) + x = x.permute(0, DIM-1, *range(1, DIM-1)).contiguous() + return x + \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/__init__.py b/thirdparty/TRELLIS/trellis/modules/sparse/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..726756c16dcfe0f04de0d2ea5bdce499fa220160 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/__init__.py @@ -0,0 +1,102 @@ +from typing import * + +BACKEND = 'spconv' +DEBUG = False +ATTN = 'flash_attn' + +def __from_env(): + import os + + global BACKEND + global DEBUG + global ATTN + + env_sparse_backend = os.environ.get('SPARSE_BACKEND') + env_sparse_debug = os.environ.get('SPARSE_DEBUG') + env_sparse_attn = os.environ.get('SPARSE_ATTN_BACKEND') + if env_sparse_attn is None: + env_sparse_attn = os.environ.get('ATTN_BACKEND') + + if env_sparse_backend is not None and env_sparse_backend in ['spconv', 'torchsparse']: + BACKEND = env_sparse_backend + if env_sparse_debug is not None: + DEBUG = env_sparse_debug == '1' + if env_sparse_attn is not None and env_sparse_attn in ['xformers', 'flash_attn']: + ATTN = env_sparse_attn + + print(f"[SPARSE] Backend: {BACKEND}, Attention: {ATTN}") + + +__from_env() + + +def set_backend(backend: Literal['spconv', 'torchsparse']): + global BACKEND + BACKEND = backend + +def set_debug(debug: bool): + global DEBUG + DEBUG = debug + +def set_attn(attn: Literal['xformers', 'flash_attn']): + global ATTN + ATTN = attn + + +import importlib + +__attributes = { + 'SparseTensor': 'basic', + 'sparse_batch_broadcast': 'basic', + 'sparse_batch_op': 'basic', + 'sparse_cat': 'basic', + 'sparse_unbind': 'basic', + 'SparseGroupNorm': 'norm', + 'SparseLayerNorm': 'norm', + 'SparseGroupNorm32': 'norm', + 'SparseLayerNorm32': 'norm', + 'SparseReLU': 'nonlinearity', + 'SparseSiLU': 'nonlinearity', + 'SparseGELU': 'nonlinearity', + 'SparseActivation': 'nonlinearity', + 'SparseLinear': 'linear', + 'sparse_scaled_dot_product_attention': 'attention', + 'SerializeMode': 'attention', + 'sparse_serialized_scaled_dot_product_self_attention': 'attention', + 'sparse_windowed_scaled_dot_product_self_attention': 'attention', + 'SparseMultiHeadAttention': 'attention', + 'SparseConv3d': 'conv', + 'SparseInverseConv3d': 'conv', + 'SparseDownsample': 'spatial', + 'SparseUpsample': 'spatial', + 'SparseSubdivide' : 'spatial' +} + +__submodules = ['transformer'] + +__all__ = list(__attributes.keys()) + __submodules + +def __getattr__(name): + if name not in globals(): + if name in __attributes: + module_name = __attributes[name] + module = importlib.import_module(f".{module_name}", __name__) + globals()[name] = getattr(module, name) + elif name in __submodules: + module = importlib.import_module(f".{name}", __name__) + globals()[name] = module + else: + raise AttributeError(f"module {__name__} has no attribute {name}") + return globals()[name] + + +# For Pylance +if __name__ == '__main__': + from .basic import * + from .norm import * + from .nonlinearity import * + from .linear import * + from .attention import * + from .conv import * + from .spatial import * + import transformer diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/attention/__init__.py b/thirdparty/TRELLIS/trellis/modules/sparse/attention/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..32b3c2c837c613e41755ac4c85f9ed057a6f5bfb --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/attention/__init__.py @@ -0,0 +1,4 @@ +from .full_attn import * +from .serialized_attn import * +from .windowed_attn import * +from .modules import * diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/attention/full_attn.py b/thirdparty/TRELLIS/trellis/modules/sparse/attention/full_attn.py new file mode 100755 index 0000000000000000000000000000000000000000..e9e27aeb98419621f3f9999fd3b11eebf2b90a40 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/attention/full_attn.py @@ -0,0 +1,215 @@ +from typing import * +import torch +from .. import SparseTensor +from .. import DEBUG, ATTN + +if ATTN == 'xformers': + import xformers.ops as xops +elif ATTN == 'flash_attn': + import flash_attn +else: + raise ValueError(f"Unknown attention module: {ATTN}") + + +__all__ = [ + 'sparse_scaled_dot_product_attention', +] + + +@overload +def sparse_scaled_dot_product_attention(qkv: SparseTensor) -> SparseTensor: + """ + Apply scaled dot product attention to a sparse tensor. + + Args: + qkv (SparseTensor): A [N, *, 3, H, C] sparse tensor containing Qs, Ks, and Vs. + """ + ... + +@overload +def sparse_scaled_dot_product_attention(q: SparseTensor, kv: Union[SparseTensor, torch.Tensor]) -> SparseTensor: + """ + Apply scaled dot product attention to a sparse tensor. + + Args: + q (SparseTensor): A [N, *, H, C] sparse tensor containing Qs. + kv (SparseTensor or torch.Tensor): A [N, *, 2, H, C] sparse tensor or a [N, L, 2, H, C] dense tensor containing Ks and Vs. + """ + ... + +@overload +def sparse_scaled_dot_product_attention(q: torch.Tensor, kv: SparseTensor) -> torch.Tensor: + """ + Apply scaled dot product attention to a sparse tensor. + + Args: + q (SparseTensor): A [N, L, H, C] dense tensor containing Qs. + kv (SparseTensor or torch.Tensor): A [N, *, 2, H, C] sparse tensor containing Ks and Vs. + """ + ... + +@overload +def sparse_scaled_dot_product_attention(q: SparseTensor, k: SparseTensor, v: SparseTensor) -> SparseTensor: + """ + Apply scaled dot product attention to a sparse tensor. + + Args: + q (SparseTensor): A [N, *, H, Ci] sparse tensor containing Qs. + k (SparseTensor): A [N, *, H, Ci] sparse tensor containing Ks. + v (SparseTensor): A [N, *, H, Co] sparse tensor containing Vs. + + Note: + k and v are assumed to have the same coordinate map. + """ + ... + +@overload +def sparse_scaled_dot_product_attention(q: SparseTensor, k: torch.Tensor, v: torch.Tensor) -> SparseTensor: + """ + Apply scaled dot product attention to a sparse tensor. + + Args: + q (SparseTensor): A [N, *, H, Ci] sparse tensor containing Qs. + k (torch.Tensor): A [N, L, H, Ci] dense tensor containing Ks. + v (torch.Tensor): A [N, L, H, Co] dense tensor containing Vs. + """ + ... + +@overload +def sparse_scaled_dot_product_attention(q: torch.Tensor, k: SparseTensor, v: SparseTensor) -> torch.Tensor: + """ + Apply scaled dot product attention to a sparse tensor. + + Args: + q (torch.Tensor): A [N, L, H, Ci] dense tensor containing Qs. + k (SparseTensor): A [N, *, H, Ci] sparse tensor containing Ks. + v (SparseTensor): A [N, *, H, Co] sparse tensor containing Vs. + """ + ... + +def sparse_scaled_dot_product_attention(*args, **kwargs): + arg_names_dict = { + 1: ['qkv'], + 2: ['q', 'kv'], + 3: ['q', 'k', 'v'] + } + num_all_args = len(args) + len(kwargs) + assert num_all_args in arg_names_dict, f"Invalid number of arguments, got {num_all_args}, expected 1, 2, or 3" + for key in arg_names_dict[num_all_args][len(args):]: + assert key in kwargs, f"Missing argument {key}" + + if num_all_args == 1: + qkv = args[0] if len(args) > 0 else kwargs['qkv'] + assert isinstance(qkv, SparseTensor), f"qkv must be a SparseTensor, got {type(qkv)}" + assert len(qkv.shape) == 4 and qkv.shape[1] == 3, f"Invalid shape for qkv, got {qkv.shape}, expected [N, *, 3, H, C]" + device = qkv.device + + s = qkv + q_seqlen = [qkv.layout[i].stop - qkv.layout[i].start for i in range(qkv.shape[0])] + kv_seqlen = q_seqlen + qkv = qkv.feats # [T, 3, H, C] + + elif num_all_args == 2: + q = args[0] if len(args) > 0 else kwargs['q'] + kv = args[1] if len(args) > 1 else kwargs['kv'] + assert isinstance(q, SparseTensor) and isinstance(kv, (SparseTensor, torch.Tensor)) or \ + isinstance(q, torch.Tensor) and isinstance(kv, SparseTensor), \ + f"Invalid types, got {type(q)} and {type(kv)}" + assert q.shape[0] == kv.shape[0], f"Batch size mismatch, got {q.shape[0]} and {kv.shape[0]}" + device = q.device + + if isinstance(q, SparseTensor): + assert len(q.shape) == 3, f"Invalid shape for q, got {q.shape}, expected [N, *, H, C]" + s = q + q_seqlen = [q.layout[i].stop - q.layout[i].start for i in range(q.shape[0])] + q = q.feats # [T_Q, H, C] + else: + assert len(q.shape) == 4, f"Invalid shape for q, got {q.shape}, expected [N, L, H, C]" + s = None + N, L, H, C = q.shape + q_seqlen = [L] * N + q = q.reshape(N * L, H, C) # [T_Q, H, C] + + if isinstance(kv, SparseTensor): + assert len(kv.shape) == 4 and kv.shape[1] == 2, f"Invalid shape for kv, got {kv.shape}, expected [N, *, 2, H, C]" + kv_seqlen = [kv.layout[i].stop - kv.layout[i].start for i in range(kv.shape[0])] + kv = kv.feats # [T_KV, 2, H, C] + else: + assert len(kv.shape) == 5, f"Invalid shape for kv, got {kv.shape}, expected [N, L, 2, H, C]" + N, L, _, H, C = kv.shape + kv_seqlen = [L] * N + kv = kv.reshape(N * L, 2, H, C) # [T_KV, 2, H, C] + + elif num_all_args == 3: + q = args[0] if len(args) > 0 else kwargs['q'] + k = args[1] if len(args) > 1 else kwargs['k'] + v = args[2] if len(args) > 2 else kwargs['v'] + assert isinstance(q, SparseTensor) and isinstance(k, (SparseTensor, torch.Tensor)) and type(k) == type(v) or \ + isinstance(q, torch.Tensor) and isinstance(k, SparseTensor) and isinstance(v, SparseTensor), \ + f"Invalid types, got {type(q)}, {type(k)}, and {type(v)}" + assert q.shape[0] == k.shape[0] == v.shape[0], f"Batch size mismatch, got {q.shape[0]}, {k.shape[0]}, and {v.shape[0]}" + device = q.device + + if isinstance(q, SparseTensor): + assert len(q.shape) == 3, f"Invalid shape for q, got {q.shape}, expected [N, *, H, Ci]" + s = q + q_seqlen = [q.layout[i].stop - q.layout[i].start for i in range(q.shape[0])] + q = q.feats # [T_Q, H, Ci] + else: + assert len(q.shape) == 4, f"Invalid shape for q, got {q.shape}, expected [N, L, H, Ci]" + s = None + N, L, H, CI = q.shape + q_seqlen = [L] * N + q = q.reshape(N * L, H, CI) # [T_Q, H, Ci] + + if isinstance(k, SparseTensor): + assert len(k.shape) == 3, f"Invalid shape for k, got {k.shape}, expected [N, *, H, Ci]" + assert len(v.shape) == 3, f"Invalid shape for v, got {v.shape}, expected [N, *, H, Co]" + kv_seqlen = [k.layout[i].stop - k.layout[i].start for i in range(k.shape[0])] + k = k.feats # [T_KV, H, Ci] + v = v.feats # [T_KV, H, Co] + else: + assert len(k.shape) == 4, f"Invalid shape for k, got {k.shape}, expected [N, L, H, Ci]" + assert len(v.shape) == 4, f"Invalid shape for v, got {v.shape}, expected [N, L, H, Co]" + N, L, H, CI, CO = *k.shape, v.shape[-1] + kv_seqlen = [L] * N + k = k.reshape(N * L, H, CI) # [T_KV, H, Ci] + v = v.reshape(N * L, H, CO) # [T_KV, H, Co] + + if DEBUG: + if s is not None: + for i in range(s.shape[0]): + assert (s.coords[s.layout[i]] == i).all(), f"SparseScaledDotProductSelfAttention: batch index mismatch" + if num_all_args in [2, 3]: + assert q.shape[:2] == [1, sum(q_seqlen)], f"SparseScaledDotProductSelfAttention: q shape mismatch" + if num_all_args == 3: + assert k.shape[:2] == [1, sum(kv_seqlen)], f"SparseScaledDotProductSelfAttention: k shape mismatch" + assert v.shape[:2] == [1, sum(kv_seqlen)], f"SparseScaledDotProductSelfAttention: v shape mismatch" + + if ATTN == 'xformers': + if num_all_args == 1: + q, k, v = qkv.unbind(dim=1) + elif num_all_args == 2: + k, v = kv.unbind(dim=1) + q = q.unsqueeze(0) + k = k.unsqueeze(0) + v = v.unsqueeze(0) + mask = xops.fmha.BlockDiagonalMask.from_seqlens(q_seqlen, kv_seqlen) + out = xops.memory_efficient_attention(q, k, v, mask)[0] + elif ATTN == 'flash_attn': + cu_seqlens_q = torch.cat([torch.tensor([0]), torch.cumsum(torch.tensor(q_seqlen), dim=0)]).int().to(device) + if num_all_args in [2, 3]: + cu_seqlens_kv = torch.cat([torch.tensor([0]), torch.cumsum(torch.tensor(kv_seqlen), dim=0)]).int().to(device) + if num_all_args == 1: + out = flash_attn.flash_attn_varlen_qkvpacked_func(qkv, cu_seqlens_q, max(q_seqlen)) + elif num_all_args == 2: + out = flash_attn.flash_attn_varlen_kvpacked_func(q, kv, cu_seqlens_q, cu_seqlens_kv, max(q_seqlen), max(kv_seqlen)) + elif num_all_args == 3: + out = flash_attn.flash_attn_varlen_func(q, k, v, cu_seqlens_q, cu_seqlens_kv, max(q_seqlen), max(kv_seqlen)) + else: + raise ValueError(f"Unknown attention module: {ATTN}") + + if s is not None: + return s.replace(out) + else: + return out.reshape(N, L, H, -1) diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/attention/modules.py b/thirdparty/TRELLIS/trellis/modules/sparse/attention/modules.py new file mode 100755 index 0000000000000000000000000000000000000000..5d2fe782b0947700e308e9ec0325e7e91c84e3c2 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/attention/modules.py @@ -0,0 +1,139 @@ +from typing import * +import torch +import torch.nn as nn +import torch.nn.functional as F +from .. import SparseTensor +from .full_attn import sparse_scaled_dot_product_attention +from .serialized_attn import SerializeMode, sparse_serialized_scaled_dot_product_self_attention +from .windowed_attn import sparse_windowed_scaled_dot_product_self_attention +from ...attention import RotaryPositionEmbedder + + +class SparseMultiHeadRMSNorm(nn.Module): + def __init__(self, dim: int, heads: int): + super().__init__() + self.scale = dim ** 0.5 + self.gamma = nn.Parameter(torch.ones(heads, dim)) + + def forward(self, x: Union[SparseTensor, torch.Tensor]) -> Union[SparseTensor, torch.Tensor]: + x_type = x.dtype + x = x.float() + if isinstance(x, SparseTensor): + x = x.replace(F.normalize(x.feats, dim=-1)) + else: + x = F.normalize(x, dim=-1) + return (x * self.gamma * self.scale).to(x_type) + + +class SparseMultiHeadAttention(nn.Module): + def __init__( + self, + channels: int, + num_heads: int, + ctx_channels: Optional[int] = None, + type: Literal["self", "cross"] = "self", + attn_mode: Literal["full", "serialized", "windowed"] = "full", + window_size: Optional[int] = None, + shift_sequence: Optional[int] = None, + shift_window: Optional[Tuple[int, int, int]] = None, + serialize_mode: Optional[SerializeMode] = None, + qkv_bias: bool = True, + use_rope: bool = False, + qk_rms_norm: bool = False, + ): + super().__init__() + assert channels % num_heads == 0 + assert type in ["self", "cross"], f"Invalid attention type: {type}" + assert attn_mode in ["full", "serialized", "windowed"], f"Invalid attention mode: {attn_mode}" + assert type == "self" or attn_mode == "full", "Cross-attention only supports full attention" + assert type == "self" or use_rope is False, "Rotary position embeddings only supported for self-attention" + self.channels = channels + self.ctx_channels = ctx_channels if ctx_channels is not None else channels + self.num_heads = num_heads + self._type = type + self.attn_mode = attn_mode + self.window_size = window_size + self.shift_sequence = shift_sequence + self.shift_window = shift_window + self.serialize_mode = serialize_mode + self.use_rope = use_rope + self.qk_rms_norm = qk_rms_norm + + if self._type == "self": + self.to_qkv = nn.Linear(channels, channels * 3, bias=qkv_bias) + else: + self.to_q = nn.Linear(channels, channels, bias=qkv_bias) + self.to_kv = nn.Linear(self.ctx_channels, channels * 2, bias=qkv_bias) + + if self.qk_rms_norm: + self.q_rms_norm = SparseMultiHeadRMSNorm(channels // num_heads, num_heads) + self.k_rms_norm = SparseMultiHeadRMSNorm(channels // num_heads, num_heads) + + self.to_out = nn.Linear(channels, channels) + + if use_rope: + self.rope = RotaryPositionEmbedder(channels) + + @staticmethod + def _linear(module: nn.Linear, x: Union[SparseTensor, torch.Tensor]) -> Union[SparseTensor, torch.Tensor]: + if isinstance(x, SparseTensor): + return x.replace(module(x.feats)) + else: + return module(x) + + @staticmethod + def _reshape_chs(x: Union[SparseTensor, torch.Tensor], shape: Tuple[int, ...]) -> Union[SparseTensor, torch.Tensor]: + if isinstance(x, SparseTensor): + return x.reshape(*shape) + else: + return x.reshape(*x.shape[:2], *shape) + + def _fused_pre(self, x: Union[SparseTensor, torch.Tensor], num_fused: int) -> Union[SparseTensor, torch.Tensor]: + if isinstance(x, SparseTensor): + x_feats = x.feats.unsqueeze(0) + else: + x_feats = x + x_feats = x_feats.reshape(*x_feats.shape[:2], num_fused, self.num_heads, -1) + return x.replace(x_feats.squeeze(0)) if isinstance(x, SparseTensor) else x_feats + + def _rope(self, qkv: SparseTensor) -> SparseTensor: + q, k, v = qkv.feats.unbind(dim=1) # [T, H, C] + q, k = self.rope(q, k, qkv.coords[:, 1:]) + qkv = qkv.replace(torch.stack([q, k, v], dim=1)) + return qkv + + def forward(self, x: Union[SparseTensor, torch.Tensor], context: Optional[Union[SparseTensor, torch.Tensor]] = None) -> Union[SparseTensor, torch.Tensor]: + if self._type == "self": + qkv = self._linear(self.to_qkv, x) + qkv = self._fused_pre(qkv, num_fused=3) + if self.use_rope: + qkv = self._rope(qkv) + if self.qk_rms_norm: + q, k, v = qkv.unbind(dim=1) + q = self.q_rms_norm(q) + k = self.k_rms_norm(k) + qkv = qkv.replace(torch.stack([q.feats, k.feats, v.feats], dim=1)) + if self.attn_mode == "full": + h = sparse_scaled_dot_product_attention(qkv) + elif self.attn_mode == "serialized": + h = sparse_serialized_scaled_dot_product_self_attention( + qkv, self.window_size, serialize_mode=self.serialize_mode, shift_sequence=self.shift_sequence, shift_window=self.shift_window + ) + elif self.attn_mode == "windowed": + h = sparse_windowed_scaled_dot_product_self_attention( + qkv, self.window_size, shift_window=self.shift_window + ) + else: + q = self._linear(self.to_q, x) + q = self._reshape_chs(q, (self.num_heads, -1)) + kv = self._linear(self.to_kv, context) + kv = self._fused_pre(kv, num_fused=2) + if self.qk_rms_norm: + q = self.q_rms_norm(q) + k, v = kv.unbind(dim=1) + k = self.k_rms_norm(k) + kv = kv.replace(torch.stack([k.feats, v.feats], dim=1)) + h = sparse_scaled_dot_product_attention(q, kv) + h = self._reshape_chs(h, (-1,)) + h = self._linear(self.to_out, h) + return h diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/attention/serialized_attn.py b/thirdparty/TRELLIS/trellis/modules/sparse/attention/serialized_attn.py new file mode 100755 index 0000000000000000000000000000000000000000..5950b75b2f5a6d6e79ab6d472b8501aaa5ec4a26 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/attention/serialized_attn.py @@ -0,0 +1,193 @@ +from typing import * +from enum import Enum +import torch +import math +from .. import SparseTensor +from .. import DEBUG, ATTN + +if ATTN == 'xformers': + import xformers.ops as xops +elif ATTN == 'flash_attn': + import flash_attn +else: + raise ValueError(f"Unknown attention module: {ATTN}") + + +__all__ = [ + 'sparse_serialized_scaled_dot_product_self_attention', +] + + +class SerializeMode(Enum): + Z_ORDER = 0 + Z_ORDER_TRANSPOSED = 1 + HILBERT = 2 + HILBERT_TRANSPOSED = 3 + + +SerializeModes = [ + SerializeMode.Z_ORDER, + SerializeMode.Z_ORDER_TRANSPOSED, + SerializeMode.HILBERT, + SerializeMode.HILBERT_TRANSPOSED +] + + +def calc_serialization( + tensor: SparseTensor, + window_size: int, + serialize_mode: SerializeMode = SerializeMode.Z_ORDER, + shift_sequence: int = 0, + shift_window: Tuple[int, int, int] = (0, 0, 0) +) -> Tuple[torch.Tensor, torch.Tensor, List[int]]: + """ + Calculate serialization and partitioning for a set of coordinates. + + Args: + tensor (SparseTensor): The input tensor. + window_size (int): The window size to use. + serialize_mode (SerializeMode): The serialization mode to use. + shift_sequence (int): The shift of serialized sequence. + shift_window (Tuple[int, int, int]): The shift of serialized coordinates. + + Returns: + (torch.Tensor, torch.Tensor): Forwards and backwards indices. + """ + fwd_indices = [] + bwd_indices = [] + seq_lens = [] + seq_batch_indices = [] + offsets = [0] + + if 'vox2seq' not in globals(): + import vox2seq + + # Serialize the input + serialize_coords = tensor.coords[:, 1:].clone() + serialize_coords += torch.tensor(shift_window, dtype=torch.int32, device=tensor.device).reshape(1, 3) + if serialize_mode == SerializeMode.Z_ORDER: + code = vox2seq.encode(serialize_coords, mode='z_order', permute=[0, 1, 2]) + elif serialize_mode == SerializeMode.Z_ORDER_TRANSPOSED: + code = vox2seq.encode(serialize_coords, mode='z_order', permute=[1, 0, 2]) + elif serialize_mode == SerializeMode.HILBERT: + code = vox2seq.encode(serialize_coords, mode='hilbert', permute=[0, 1, 2]) + elif serialize_mode == SerializeMode.HILBERT_TRANSPOSED: + code = vox2seq.encode(serialize_coords, mode='hilbert', permute=[1, 0, 2]) + else: + raise ValueError(f"Unknown serialize mode: {serialize_mode}") + + for bi, s in enumerate(tensor.layout): + num_points = s.stop - s.start + num_windows = (num_points + window_size - 1) // window_size + valid_window_size = num_points / num_windows + to_ordered = torch.argsort(code[s.start:s.stop]) + if num_windows == 1: + fwd_indices.append(to_ordered) + bwd_indices.append(torch.zeros_like(to_ordered).scatter_(0, to_ordered, torch.arange(num_points, device=tensor.device))) + fwd_indices[-1] += s.start + bwd_indices[-1] += offsets[-1] + seq_lens.append(num_points) + seq_batch_indices.append(bi) + offsets.append(offsets[-1] + seq_lens[-1]) + else: + # Partition the input + offset = 0 + mids = [(i + 0.5) * valid_window_size + shift_sequence for i in range(num_windows)] + split = [math.floor(i * valid_window_size + shift_sequence) for i in range(num_windows + 1)] + bwd_index = torch.zeros((num_points,), dtype=torch.int64, device=tensor.device) + for i in range(num_windows): + mid = mids[i] + valid_start = split[i] + valid_end = split[i + 1] + padded_start = math.floor(mid - 0.5 * window_size) + padded_end = padded_start + window_size + fwd_indices.append(to_ordered[torch.arange(padded_start, padded_end, device=tensor.device) % num_points]) + offset += valid_start - padded_start + bwd_index.scatter_(0, fwd_indices[-1][valid_start-padded_start:valid_end-padded_start], torch.arange(offset, offset + valid_end - valid_start, device=tensor.device)) + offset += padded_end - valid_start + fwd_indices[-1] += s.start + seq_lens.extend([window_size] * num_windows) + seq_batch_indices.extend([bi] * num_windows) + bwd_indices.append(bwd_index + offsets[-1]) + offsets.append(offsets[-1] + num_windows * window_size) + + fwd_indices = torch.cat(fwd_indices) + bwd_indices = torch.cat(bwd_indices) + + return fwd_indices, bwd_indices, seq_lens, seq_batch_indices + + +def sparse_serialized_scaled_dot_product_self_attention( + qkv: SparseTensor, + window_size: int, + serialize_mode: SerializeMode = SerializeMode.Z_ORDER, + shift_sequence: int = 0, + shift_window: Tuple[int, int, int] = (0, 0, 0) +) -> SparseTensor: + """ + Apply serialized scaled dot product self attention to a sparse tensor. + + Args: + qkv (SparseTensor): [N, *, 3, H, C] sparse tensor containing Qs, Ks, and Vs. + window_size (int): The window size to use. + serialize_mode (SerializeMode): The serialization mode to use. + shift_sequence (int): The shift of serialized sequence. + shift_window (Tuple[int, int, int]): The shift of serialized coordinates. + shift (int): The shift to use. + """ + assert len(qkv.shape) == 4 and qkv.shape[1] == 3, f"Invalid shape for qkv, got {qkv.shape}, expected [N, *, 3, H, C]" + + serialization_spatial_cache_name = f'serialization_{serialize_mode}_{window_size}_{shift_sequence}_{shift_window}' + serialization_spatial_cache = qkv.get_spatial_cache(serialization_spatial_cache_name) + if serialization_spatial_cache is None: + fwd_indices, bwd_indices, seq_lens, seq_batch_indices = calc_serialization(qkv, window_size, serialize_mode, shift_sequence, shift_window) + qkv.register_spatial_cache(serialization_spatial_cache_name, (fwd_indices, bwd_indices, seq_lens, seq_batch_indices)) + else: + fwd_indices, bwd_indices, seq_lens, seq_batch_indices = serialization_spatial_cache + + M = fwd_indices.shape[0] + T = qkv.feats.shape[0] + H = qkv.feats.shape[2] + C = qkv.feats.shape[3] + + qkv_feats = qkv.feats[fwd_indices] # [M, 3, H, C] + + if DEBUG: + start = 0 + qkv_coords = qkv.coords[fwd_indices] + for i in range(len(seq_lens)): + assert (qkv_coords[start:start+seq_lens[i], 0] == seq_batch_indices[i]).all(), f"SparseWindowedScaledDotProductSelfAttention: batch index mismatch" + start += seq_lens[i] + + if all([seq_len == window_size for seq_len in seq_lens]): + B = len(seq_lens) + N = window_size + qkv_feats = qkv_feats.reshape(B, N, 3, H, C) + if ATTN == 'xformers': + q, k, v = qkv_feats.unbind(dim=2) # [B, N, H, C] + out = xops.memory_efficient_attention(q, k, v) # [B, N, H, C] + elif ATTN == 'flash_attn': + out = flash_attn.flash_attn_qkvpacked_func(qkv_feats) # [B, N, H, C] + else: + raise ValueError(f"Unknown attention module: {ATTN}") + out = out.reshape(B * N, H, C) # [M, H, C] + else: + if ATTN == 'xformers': + q, k, v = qkv_feats.unbind(dim=1) # [M, H, C] + q = q.unsqueeze(0) # [1, M, H, C] + k = k.unsqueeze(0) # [1, M, H, C] + v = v.unsqueeze(0) # [1, M, H, C] + mask = xops.fmha.BlockDiagonalMask.from_seqlens(seq_lens) + out = xops.memory_efficient_attention(q, k, v, mask)[0] # [M, H, C] + elif ATTN == 'flash_attn': + cu_seqlens = torch.cat([torch.tensor([0]), torch.cumsum(torch.tensor(seq_lens), dim=0)], dim=0) \ + .to(qkv.device).int() + out = flash_attn.flash_attn_varlen_qkvpacked_func(qkv_feats, cu_seqlens, max(seq_lens)) # [M, H, C] + + out = out[bwd_indices] # [T, H, C] + + if DEBUG: + qkv_coords = qkv_coords[bwd_indices] + assert torch.equal(qkv_coords, qkv.coords), "SparseWindowedScaledDotProductSelfAttention: coordinate mismatch" + + return qkv.replace(out) diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/attention/windowed_attn.py b/thirdparty/TRELLIS/trellis/modules/sparse/attention/windowed_attn.py new file mode 100755 index 0000000000000000000000000000000000000000..cd642c5252e29a3a5e59fad7ed3880b7b00bcf9a --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/attention/windowed_attn.py @@ -0,0 +1,135 @@ +from typing import * +import torch +import math +from .. import SparseTensor +from .. import DEBUG, ATTN + +if ATTN == 'xformers': + import xformers.ops as xops +elif ATTN == 'flash_attn': + import flash_attn +else: + raise ValueError(f"Unknown attention module: {ATTN}") + + +__all__ = [ + 'sparse_windowed_scaled_dot_product_self_attention', +] + + +def calc_window_partition( + tensor: SparseTensor, + window_size: Union[int, Tuple[int, ...]], + shift_window: Union[int, Tuple[int, ...]] = 0 +) -> Tuple[torch.Tensor, torch.Tensor, List[int], List[int]]: + """ + Calculate serialization and partitioning for a set of coordinates. + + Args: + tensor (SparseTensor): The input tensor. + window_size (int): The window size to use. + shift_window (Tuple[int, ...]): The shift of serialized coordinates. + + Returns: + (torch.Tensor): Forwards indices. + (torch.Tensor): Backwards indices. + (List[int]): Sequence lengths. + (List[int]): Sequence batch indices. + """ + DIM = tensor.coords.shape[1] - 1 + shift_window = (shift_window,) * DIM if isinstance(shift_window, int) else shift_window + window_size = (window_size,) * DIM if isinstance(window_size, int) else window_size + shifted_coords = tensor.coords.clone().detach() + shifted_coords[:, 1:] += torch.tensor(shift_window, device=tensor.device, dtype=torch.int32).unsqueeze(0) + + MAX_COORDS = shifted_coords[:, 1:].max(dim=0).values.tolist() + NUM_WINDOWS = [math.ceil((mc + 1) / ws) for mc, ws in zip(MAX_COORDS, window_size)] + OFFSET = torch.cumprod(torch.tensor([1] + NUM_WINDOWS[::-1]), dim=0).tolist()[::-1] + + shifted_coords[:, 1:] //= torch.tensor(window_size, device=tensor.device, dtype=torch.int32).unsqueeze(0) + shifted_indices = (shifted_coords * torch.tensor(OFFSET, device=tensor.device, dtype=torch.int32).unsqueeze(0)).sum(dim=1) + fwd_indices = torch.argsort(shifted_indices) + bwd_indices = torch.empty_like(fwd_indices) + bwd_indices[fwd_indices] = torch.arange(fwd_indices.shape[0], device=tensor.device) + seq_lens = torch.bincount(shifted_indices) + seq_batch_indices = torch.arange(seq_lens.shape[0], device=tensor.device, dtype=torch.int32) // OFFSET[0] + mask = seq_lens != 0 + seq_lens = seq_lens[mask].tolist() + seq_batch_indices = seq_batch_indices[mask].tolist() + + return fwd_indices, bwd_indices, seq_lens, seq_batch_indices + + +def sparse_windowed_scaled_dot_product_self_attention( + qkv: SparseTensor, + window_size: int, + shift_window: Tuple[int, int, int] = (0, 0, 0) +) -> SparseTensor: + """ + Apply windowed scaled dot product self attention to a sparse tensor. + + Args: + qkv (SparseTensor): [N, *, 3, H, C] sparse tensor containing Qs, Ks, and Vs. + window_size (int): The window size to use. + shift_window (Tuple[int, int, int]): The shift of serialized coordinates. + shift (int): The shift to use. + """ + assert len(qkv.shape) == 4 and qkv.shape[1] == 3, f"Invalid shape for qkv, got {qkv.shape}, expected [N, *, 3, H, C]" + + serialization_spatial_cache_name = f'window_partition_{window_size}_{shift_window}' + serialization_spatial_cache = qkv.get_spatial_cache(serialization_spatial_cache_name) + if serialization_spatial_cache is None: + fwd_indices, bwd_indices, seq_lens, seq_batch_indices = calc_window_partition(qkv, window_size, shift_window) + qkv.register_spatial_cache(serialization_spatial_cache_name, (fwd_indices, bwd_indices, seq_lens, seq_batch_indices)) + else: + fwd_indices, bwd_indices, seq_lens, seq_batch_indices = serialization_spatial_cache + + M = fwd_indices.shape[0] + T = qkv.feats.shape[0] + H = qkv.feats.shape[2] + C = qkv.feats.shape[3] + + qkv_feats = qkv.feats[fwd_indices] # [M, 3, H, C] + + if DEBUG: + start = 0 + qkv_coords = qkv.coords[fwd_indices] + for i in range(len(seq_lens)): + seq_coords = qkv_coords[start:start+seq_lens[i]] + assert (seq_coords[:, 0] == seq_batch_indices[i]).all(), f"SparseWindowedScaledDotProductSelfAttention: batch index mismatch" + assert (seq_coords[:, 1:].max(dim=0).values - seq_coords[:, 1:].min(dim=0).values < window_size).all(), \ + f"SparseWindowedScaledDotProductSelfAttention: window size exceeded" + start += seq_lens[i] + + if all([seq_len == window_size for seq_len in seq_lens]): + B = len(seq_lens) + N = window_size + qkv_feats = qkv_feats.reshape(B, N, 3, H, C) + if ATTN == 'xformers': + q, k, v = qkv_feats.unbind(dim=2) # [B, N, H, C] + out = xops.memory_efficient_attention(q, k, v) # [B, N, H, C] + elif ATTN == 'flash_attn': + out = flash_attn.flash_attn_qkvpacked_func(qkv_feats) # [B, N, H, C] + else: + raise ValueError(f"Unknown attention module: {ATTN}") + out = out.reshape(B * N, H, C) # [M, H, C] + else: + if ATTN == 'xformers': + q, k, v = qkv_feats.unbind(dim=1) # [M, H, C] + q = q.unsqueeze(0) # [1, M, H, C] + k = k.unsqueeze(0) # [1, M, H, C] + v = v.unsqueeze(0) # [1, M, H, C] + mask = xops.fmha.BlockDiagonalMask.from_seqlens(seq_lens) + out = xops.memory_efficient_attention(q, k, v, mask)[0] # [M, H, C] + elif ATTN == 'flash_attn': + cu_seqlens = torch.cat([torch.tensor([0]), torch.cumsum(torch.tensor(seq_lens), dim=0)], dim=0) \ + .to(qkv.device).int() + out = flash_attn.flash_attn_varlen_qkvpacked_func(qkv_feats, cu_seqlens, max(seq_lens)) # [M, H, C] + + out = out[bwd_indices] # [T, H, C] + + if DEBUG: + qkv_coords = qkv_coords[bwd_indices] + assert torch.equal(qkv_coords, qkv.coords), "SparseWindowedScaledDotProductSelfAttention: coordinate mismatch" + + return qkv.replace(out) diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/basic.py b/thirdparty/TRELLIS/trellis/modules/sparse/basic.py new file mode 100755 index 0000000000000000000000000000000000000000..8837f44052f6d573d09e3bfb897e659e10516bb5 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/basic.py @@ -0,0 +1,459 @@ +from typing import * +import torch +import torch.nn as nn +from . import BACKEND, DEBUG +SparseTensorData = None # Lazy import + + +__all__ = [ + 'SparseTensor', + 'sparse_batch_broadcast', + 'sparse_batch_op', + 'sparse_cat', + 'sparse_unbind', +] + + +class SparseTensor: + """ + Sparse tensor with support for both torchsparse and spconv backends. + + Parameters: + - feats (torch.Tensor): Features of the sparse tensor. + - coords (torch.Tensor): Coordinates of the sparse tensor. + - shape (torch.Size): Shape of the sparse tensor. + - layout (List[slice]): Layout of the sparse tensor for each batch + - data (SparseTensorData): Sparse tensor data used for convolusion + + NOTE: + - Data corresponding to a same batch should be contiguous. + - Coords should be in [0, 1023] + """ + @overload + def __init__(self, feats: torch.Tensor, coords: torch.Tensor, shape: Optional[torch.Size] = None, layout: Optional[List[slice]] = None, **kwargs): ... + + @overload + def __init__(self, data, shape: Optional[torch.Size] = None, layout: Optional[List[slice]] = None, **kwargs): ... + + def __init__(self, *args, **kwargs): + # Lazy import of sparse tensor backend + global SparseTensorData + if SparseTensorData is None: + import importlib + if BACKEND == 'torchsparse': + SparseTensorData = importlib.import_module('torchsparse').SparseTensor + elif BACKEND == 'spconv': + SparseTensorData = importlib.import_module('spconv.pytorch').SparseConvTensor + + method_id = 0 + if len(args) != 0: + method_id = 0 if isinstance(args[0], torch.Tensor) else 1 + else: + method_id = 1 if 'data' in kwargs else 0 + + if method_id == 0: + feats, coords, shape, layout = args + (None,) * (4 - len(args)) + if 'feats' in kwargs: + feats = kwargs['feats'] + del kwargs['feats'] + if 'coords' in kwargs: + coords = kwargs['coords'] + del kwargs['coords'] + if 'shape' in kwargs: + shape = kwargs['shape'] + del kwargs['shape'] + if 'layout' in kwargs: + layout = kwargs['layout'] + del kwargs['layout'] + + if shape is None: + shape = self.__cal_shape(feats, coords) + if layout is None: + layout = self.__cal_layout(coords, shape[0]) + if BACKEND == 'torchsparse': + self.data = SparseTensorData(feats, coords, **kwargs) + elif BACKEND == 'spconv': + spatial_shape = list(coords.max(0)[0] + 1)[1:] + self.data = SparseTensorData(feats.reshape(feats.shape[0], -1), coords, spatial_shape, shape[0], **kwargs) + self.data._features = feats + elif method_id == 1: + data, shape, layout = args + (None,) * (3 - len(args)) + if 'data' in kwargs: + data = kwargs['data'] + del kwargs['data'] + if 'shape' in kwargs: + shape = kwargs['shape'] + del kwargs['shape'] + if 'layout' in kwargs: + layout = kwargs['layout'] + del kwargs['layout'] + + self.data = data + if shape is None: + shape = self.__cal_shape(self.feats, self.coords) + if layout is None: + layout = self.__cal_layout(self.coords, shape[0]) + + self._shape = shape + self._layout = layout + self._scale = kwargs.get('scale', (1, 1, 1)) + self._spatial_cache = kwargs.get('spatial_cache', {}) + + if DEBUG: + try: + assert self.feats.shape[0] == self.coords.shape[0], f"Invalid feats shape: {self.feats.shape}, coords shape: {self.coords.shape}" + assert self.shape == self.__cal_shape(self.feats, self.coords), f"Invalid shape: {self.shape}" + assert self.layout == self.__cal_layout(self.coords, self.shape[0]), f"Invalid layout: {self.layout}" + for i in range(self.shape[0]): + assert torch.all(self.coords[self.layout[i], 0] == i), f"The data of batch {i} is not contiguous" + except Exception as e: + print('Debugging information:') + print(f"- Shape: {self.shape}") + print(f"- Layout: {self.layout}") + print(f"- Scale: {self._scale}") + print(f"- Coords: {self.coords}") + raise e + + def __cal_shape(self, feats, coords): + shape = [] + shape.append(coords[:, 0].max().item() + 1) + shape.extend([*feats.shape[1:]]) + return torch.Size(shape) + + def __cal_layout(self, coords, batch_size): + seq_len = torch.bincount(coords[:, 0], minlength=batch_size) + offset = torch.cumsum(seq_len, dim=0) + layout = [slice((offset[i] - seq_len[i]).item(), offset[i].item()) for i in range(batch_size)] + return layout + + @property + def shape(self) -> torch.Size: + return self._shape + + def dim(self) -> int: + return len(self.shape) + + @property + def layout(self) -> List[slice]: + return self._layout + + @property + def feats(self) -> torch.Tensor: + if BACKEND == 'torchsparse': + return self.data.F + elif BACKEND == 'spconv': + return self.data.features + + @feats.setter + def feats(self, value: torch.Tensor): + if BACKEND == 'torchsparse': + self.data.F = value + elif BACKEND == 'spconv': + self.data.features = value + + @property + def coords(self) -> torch.Tensor: + if BACKEND == 'torchsparse': + return self.data.C + elif BACKEND == 'spconv': + return self.data.indices + + @coords.setter + def coords(self, value: torch.Tensor): + if BACKEND == 'torchsparse': + self.data.C = value + elif BACKEND == 'spconv': + self.data.indices = value + + @property + def dtype(self): + return self.feats.dtype + + @property + def device(self): + return self.feats.device + + @overload + def to(self, dtype: torch.dtype) -> 'SparseTensor': ... + + @overload + def to(self, device: Optional[Union[str, torch.device]] = None, dtype: Optional[torch.dtype] = None) -> 'SparseTensor': ... + + def to(self, *args, **kwargs) -> 'SparseTensor': + device = None + dtype = None + if len(args) == 2: + device, dtype = args + elif len(args) == 1: + if isinstance(args[0], torch.dtype): + dtype = args[0] + else: + device = args[0] + if 'dtype' in kwargs: + assert dtype is None, "to() received multiple values for argument 'dtype'" + dtype = kwargs['dtype'] + if 'device' in kwargs: + assert device is None, "to() received multiple values for argument 'device'" + device = kwargs['device'] + + new_feats = self.feats.to(device=device, dtype=dtype) + new_coords = self.coords.to(device=device) + return self.replace(new_feats, new_coords) + + def type(self, dtype): + new_feats = self.feats.type(dtype) + return self.replace(new_feats) + + def cpu(self) -> 'SparseTensor': + new_feats = self.feats.cpu() + new_coords = self.coords.cpu() + return self.replace(new_feats, new_coords) + + def cuda(self) -> 'SparseTensor': + new_feats = self.feats.cuda() + new_coords = self.coords.cuda() + return self.replace(new_feats, new_coords) + + def half(self) -> 'SparseTensor': + new_feats = self.feats.half() + return self.replace(new_feats) + + def float(self) -> 'SparseTensor': + new_feats = self.feats.float() + return self.replace(new_feats) + + def detach(self) -> 'SparseTensor': + new_coords = self.coords.detach() + new_feats = self.feats.detach() + return self.replace(new_feats, new_coords) + + def dense(self) -> torch.Tensor: + if BACKEND == 'torchsparse': + return self.data.dense() + elif BACKEND == 'spconv': + return self.data.dense() + + def reshape(self, *shape) -> 'SparseTensor': + new_feats = self.feats.reshape(self.feats.shape[0], *shape) + return self.replace(new_feats) + + def unbind(self, dim: int) -> List['SparseTensor']: + return sparse_unbind(self, dim) + + def replace(self, feats: torch.Tensor, coords: Optional[torch.Tensor] = None) -> 'SparseTensor': + new_shape = [self.shape[0]] + new_shape.extend(feats.shape[1:]) + if BACKEND == 'torchsparse': + new_data = SparseTensorData( + feats=feats, + coords=self.data.coords if coords is None else coords, + stride=self.data.stride, + spatial_range=self.data.spatial_range, + ) + new_data._caches = self.data._caches + elif BACKEND == 'spconv': + new_data = SparseTensorData( + self.data.features.reshape(self.data.features.shape[0], -1), + self.data.indices, + self.data.spatial_shape, + self.data.batch_size, + self.data.grid, + self.data.voxel_num, + self.data.indice_dict + ) + new_data._features = feats + new_data.benchmark = self.data.benchmark + new_data.benchmark_record = self.data.benchmark_record + new_data.thrust_allocator = self.data.thrust_allocator + new_data._timer = self.data._timer + new_data.force_algo = self.data.force_algo + new_data.int8_scale = self.data.int8_scale + if coords is not None: + new_data.indices = coords + new_tensor = SparseTensor(new_data, shape=torch.Size(new_shape), layout=self.layout, scale=self._scale, spatial_cache=self._spatial_cache) + return new_tensor + + @staticmethod + def full(aabb, dim, value, dtype=torch.float32, device=None) -> 'SparseTensor': + N, C = dim + x = torch.arange(aabb[0], aabb[3] + 1) + y = torch.arange(aabb[1], aabb[4] + 1) + z = torch.arange(aabb[2], aabb[5] + 1) + coords = torch.stack(torch.meshgrid(x, y, z, indexing='ij'), dim=-1).reshape(-1, 3) + coords = torch.cat([ + torch.arange(N).view(-1, 1).repeat(1, coords.shape[0]).view(-1, 1), + coords.repeat(N, 1), + ], dim=1).to(dtype=torch.int32, device=device) + feats = torch.full((coords.shape[0], C), value, dtype=dtype, device=device) + return SparseTensor(feats=feats, coords=coords) + + def __merge_sparse_cache(self, other: 'SparseTensor') -> dict: + new_cache = {} + for k in set(list(self._spatial_cache.keys()) + list(other._spatial_cache.keys())): + if k in self._spatial_cache: + new_cache[k] = self._spatial_cache[k] + if k in other._spatial_cache: + if k not in new_cache: + new_cache[k] = other._spatial_cache[k] + else: + new_cache[k].update(other._spatial_cache[k]) + return new_cache + + def __neg__(self) -> 'SparseTensor': + return self.replace(-self.feats) + + def __elemwise__(self, other: Union[torch.Tensor, 'SparseTensor'], op: callable) -> 'SparseTensor': + if isinstance(other, torch.Tensor): + try: + other = torch.broadcast_to(other, self.shape) + other = sparse_batch_broadcast(self, other) + except: + pass + if isinstance(other, SparseTensor): + other = other.feats + new_feats = op(self.feats, other) + new_tensor = self.replace(new_feats) + if isinstance(other, SparseTensor): + new_tensor._spatial_cache = self.__merge_sparse_cache(other) + return new_tensor + + def __add__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor': + return self.__elemwise__(other, torch.add) + + def __radd__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor': + return self.__elemwise__(other, torch.add) + + def __sub__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor': + return self.__elemwise__(other, torch.sub) + + def __rsub__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor': + return self.__elemwise__(other, lambda x, y: torch.sub(y, x)) + + def __mul__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor': + return self.__elemwise__(other, torch.mul) + + def __rmul__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor': + return self.__elemwise__(other, torch.mul) + + def __truediv__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor': + return self.__elemwise__(other, torch.div) + + def __rtruediv__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor': + return self.__elemwise__(other, lambda x, y: torch.div(y, x)) + + def __getitem__(self, idx): + if isinstance(idx, int): + idx = [idx] + elif isinstance(idx, slice): + idx = range(*idx.indices(self.shape[0])) + elif isinstance(idx, torch.Tensor): + if idx.dtype == torch.bool: + assert idx.shape == (self.shape[0],), f"Invalid index shape: {idx.shape}" + idx = idx.nonzero().squeeze(1) + elif idx.dtype in [torch.int32, torch.int64]: + assert len(idx.shape) == 1, f"Invalid index shape: {idx.shape}" + else: + raise ValueError(f"Unknown index type: {idx.dtype}") + else: + raise ValueError(f"Unknown index type: {type(idx)}") + + coords = [] + feats = [] + for new_idx, old_idx in enumerate(idx): + coords.append(self.coords[self.layout[old_idx]].clone()) + coords[-1][:, 0] = new_idx + feats.append(self.feats[self.layout[old_idx]]) + coords = torch.cat(coords, dim=0).contiguous() + feats = torch.cat(feats, dim=0).contiguous() + return SparseTensor(feats=feats, coords=coords) + + def register_spatial_cache(self, key, value) -> None: + """ + Register a spatial cache. + The spatial cache can be any thing you want to cache. + The registery and retrieval of the cache is based on current scale. + """ + scale_key = str(self._scale) + if scale_key not in self._spatial_cache: + self._spatial_cache[scale_key] = {} + self._spatial_cache[scale_key][key] = value + + def get_spatial_cache(self, key=None): + """ + Get a spatial cache. + """ + scale_key = str(self._scale) + cur_scale_cache = self._spatial_cache.get(scale_key, {}) + if key is None: + return cur_scale_cache + return cur_scale_cache.get(key, None) + + +def sparse_batch_broadcast(input: SparseTensor, other: torch.Tensor) -> torch.Tensor: + """ + Broadcast a 1D tensor to a sparse tensor along the batch dimension then perform an operation. + + Args: + input (torch.Tensor): 1D tensor to broadcast. + target (SparseTensor): Sparse tensor to broadcast to. + op (callable): Operation to perform after broadcasting. Defaults to torch.add. + """ + coords, feats = input.coords, input.feats + broadcasted = torch.zeros_like(feats) + for k in range(input.shape[0]): + broadcasted[input.layout[k]] = other[k] + return broadcasted + + +def sparse_batch_op(input: SparseTensor, other: torch.Tensor, op: callable = torch.add) -> SparseTensor: + """ + Broadcast a 1D tensor to a sparse tensor along the batch dimension then perform an operation. + + Args: + input (torch.Tensor): 1D tensor to broadcast. + target (SparseTensor): Sparse tensor to broadcast to. + op (callable): Operation to perform after broadcasting. Defaults to torch.add. + """ + return input.replace(op(input.feats, sparse_batch_broadcast(input, other))) + + +def sparse_cat(inputs: List[SparseTensor], dim: int = 0) -> SparseTensor: + """ + Concatenate a list of sparse tensors. + + Args: + inputs (List[SparseTensor]): List of sparse tensors to concatenate. + """ + if dim == 0: + start = 0 + coords = [] + for input in inputs: + coords.append(input.coords.clone()) + coords[-1][:, 0] += start + start += input.shape[0] + coords = torch.cat(coords, dim=0) + feats = torch.cat([input.feats for input in inputs], dim=0) + output = SparseTensor( + coords=coords, + feats=feats, + ) + else: + feats = torch.cat([input.feats for input in inputs], dim=dim) + output = inputs[0].replace(feats) + + return output + + +def sparse_unbind(input: SparseTensor, dim: int) -> List[SparseTensor]: + """ + Unbind a sparse tensor along a dimension. + + Args: + input (SparseTensor): Sparse tensor to unbind. + dim (int): Dimension to unbind. + """ + if dim == 0: + return [input[i] for i in range(input.shape[0])] + else: + feats = input.feats.unbind(dim) + return [input.replace(f) for f in feats] diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/conv/__init__.py b/thirdparty/TRELLIS/trellis/modules/sparse/conv/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..340a87126a8de574ee0276feb96b49824a2ce234 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/conv/__init__.py @@ -0,0 +1,21 @@ +from .. import BACKEND + + +SPCONV_ALGO = 'auto' # 'auto', 'implicit_gemm', 'native' + +def __from_env(): + import os + + global SPCONV_ALGO + env_spconv_algo = os.environ.get('SPCONV_ALGO') + if env_spconv_algo is not None and env_spconv_algo in ['auto', 'implicit_gemm', 'native']: + SPCONV_ALGO = env_spconv_algo + print(f"[SPARSE][CONV] spconv algo: {SPCONV_ALGO}") + + +__from_env() + +if BACKEND == 'torchsparse': + from .conv_torchsparse import * +elif BACKEND == 'spconv': + from .conv_spconv import * diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/conv/conv_spconv.py b/thirdparty/TRELLIS/trellis/modules/sparse/conv/conv_spconv.py new file mode 100755 index 0000000000000000000000000000000000000000..524bcd4a845b2d6bd090a5f74bc8859978727528 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/conv/conv_spconv.py @@ -0,0 +1,80 @@ +import torch +import torch.nn as nn +from .. import SparseTensor +from .. import DEBUG +from . import SPCONV_ALGO + +class SparseConv3d(nn.Module): + def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, padding=None, bias=True, indice_key=None): + super(SparseConv3d, self).__init__() + if 'spconv' not in globals(): + import spconv.pytorch as spconv + algo = None + if SPCONV_ALGO == 'native': + algo = spconv.ConvAlgo.Native + elif SPCONV_ALGO == 'implicit_gemm': + algo = spconv.ConvAlgo.MaskImplicitGemm + if stride == 1 and (padding is None): + self.conv = spconv.SubMConv3d(in_channels, out_channels, kernel_size, dilation=dilation, bias=bias, indice_key=indice_key, algo=algo) + else: + self.conv = spconv.SparseConv3d(in_channels, out_channels, kernel_size, stride=stride, dilation=dilation, padding=padding, bias=bias, indice_key=indice_key, algo=algo) + self.stride = tuple(stride) if isinstance(stride, (list, tuple)) else (stride, stride, stride) + self.padding = padding + + def forward(self, x: SparseTensor) -> SparseTensor: + spatial_changed = any(s != 1 for s in self.stride) or (self.padding is not None) + new_data = self.conv(x.data) + new_shape = [x.shape[0], self.conv.out_channels] + new_layout = None if spatial_changed else x.layout + + if spatial_changed and (x.shape[0] != 1): + # spconv was non-1 stride will break the contiguous of the output tensor, sort by the coords + fwd = new_data.indices[:, 0].argsort() + bwd = torch.zeros_like(fwd).scatter_(0, fwd, torch.arange(fwd.shape[0], device=fwd.device)) + sorted_feats = new_data.features[fwd] + sorted_coords = new_data.indices[fwd] + unsorted_data = new_data + new_data = spconv.SparseConvTensor(sorted_feats, sorted_coords, unsorted_data.spatial_shape, unsorted_data.batch_size) # type: ignore + + out = SparseTensor( + new_data, shape=torch.Size(new_shape), layout=new_layout, + scale=tuple([s * stride for s, stride in zip(x._scale, self.stride)]), + spatial_cache=x._spatial_cache, + ) + + if spatial_changed and (x.shape[0] != 1): + out.register_spatial_cache(f'conv_{self.stride}_unsorted_data', unsorted_data) + out.register_spatial_cache(f'conv_{self.stride}_sort_bwd', bwd) + + return out + + +class SparseInverseConv3d(nn.Module): + def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, bias=True, indice_key=None): + super(SparseInverseConv3d, self).__init__() + if 'spconv' not in globals(): + import spconv.pytorch as spconv + self.conv = spconv.SparseInverseConv3d(in_channels, out_channels, kernel_size, bias=bias, indice_key=indice_key) + self.stride = tuple(stride) if isinstance(stride, (list, tuple)) else (stride, stride, stride) + + def forward(self, x: SparseTensor) -> SparseTensor: + spatial_changed = any(s != 1 for s in self.stride) + if spatial_changed: + # recover the original spconv order + data = x.get_spatial_cache(f'conv_{self.stride}_unsorted_data') + bwd = x.get_spatial_cache(f'conv_{self.stride}_sort_bwd') + data = data.replace_feature(x.feats[bwd]) + if DEBUG: + assert torch.equal(data.indices, x.coords[bwd]), 'Recover the original order failed' + else: + data = x.data + + new_data = self.conv(data) + new_shape = [x.shape[0], self.conv.out_channels] + new_layout = None if spatial_changed else x.layout + out = SparseTensor( + new_data, shape=torch.Size(new_shape), layout=new_layout, + scale=tuple([s // stride for s, stride in zip(x._scale, self.stride)]), + spatial_cache=x._spatial_cache, + ) + return out diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/conv/conv_torchsparse.py b/thirdparty/TRELLIS/trellis/modules/sparse/conv/conv_torchsparse.py new file mode 100755 index 0000000000000000000000000000000000000000..1d612582d4b31f90aca3c00b693bbbc2550dc62c --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/conv/conv_torchsparse.py @@ -0,0 +1,38 @@ +import torch +import torch.nn as nn +from .. import SparseTensor + + +class SparseConv3d(nn.Module): + def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, bias=True, indice_key=None): + super(SparseConv3d, self).__init__() + if 'torchsparse' not in globals(): + import torchsparse + self.conv = torchsparse.nn.Conv3d(in_channels, out_channels, kernel_size, stride, 0, dilation, bias) + + def forward(self, x: SparseTensor) -> SparseTensor: + out = self.conv(x.data) + new_shape = [x.shape[0], self.conv.out_channels] + out = SparseTensor(out, shape=torch.Size(new_shape), layout=x.layout if all(s == 1 for s in self.conv.stride) else None) + out._spatial_cache = x._spatial_cache + out._scale = tuple([s * stride for s, stride in zip(x._scale, self.conv.stride)]) + return out + + +class SparseInverseConv3d(nn.Module): + def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, bias=True, indice_key=None): + super(SparseInverseConv3d, self).__init__() + if 'torchsparse' not in globals(): + import torchsparse + self.conv = torchsparse.nn.Conv3d(in_channels, out_channels, kernel_size, stride, 0, dilation, bias, transposed=True) + + def forward(self, x: SparseTensor) -> SparseTensor: + out = self.conv(x.data) + new_shape = [x.shape[0], self.conv.out_channels] + out = SparseTensor(out, shape=torch.Size(new_shape), layout=x.layout if all(s == 1 for s in self.conv.stride) else None) + out._spatial_cache = x._spatial_cache + out._scale = tuple([s // stride for s, stride in zip(x._scale, self.conv.stride)]) + return out + + + diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/linear.py b/thirdparty/TRELLIS/trellis/modules/sparse/linear.py new file mode 100755 index 0000000000000000000000000000000000000000..a854e77ce87d1a190b9730d91f363a821ff250bd --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/linear.py @@ -0,0 +1,15 @@ +import torch +import torch.nn as nn +from . import SparseTensor + +__all__ = [ + 'SparseLinear' +] + + +class SparseLinear(nn.Linear): + def __init__(self, in_features, out_features, bias=True): + super(SparseLinear, self).__init__(in_features, out_features, bias) + + def forward(self, input: SparseTensor) -> SparseTensor: + return input.replace(super().forward(input.feats)) diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/nonlinearity.py b/thirdparty/TRELLIS/trellis/modules/sparse/nonlinearity.py new file mode 100755 index 0000000000000000000000000000000000000000..f200098dd82011a3aeee1688b9eb17018fa78295 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/nonlinearity.py @@ -0,0 +1,35 @@ +import torch +import torch.nn as nn +from . import SparseTensor + +__all__ = [ + 'SparseReLU', + 'SparseSiLU', + 'SparseGELU', + 'SparseActivation' +] + + +class SparseReLU(nn.ReLU): + def forward(self, input: SparseTensor) -> SparseTensor: + return input.replace(super().forward(input.feats)) + + +class SparseSiLU(nn.SiLU): + def forward(self, input: SparseTensor) -> SparseTensor: + return input.replace(super().forward(input.feats)) + + +class SparseGELU(nn.GELU): + def forward(self, input: SparseTensor) -> SparseTensor: + return input.replace(super().forward(input.feats)) + + +class SparseActivation(nn.Module): + def __init__(self, activation: nn.Module): + super().__init__() + self.activation = activation + + def forward(self, input: SparseTensor) -> SparseTensor: + return input.replace(self.activation(input.feats)) + diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/norm.py b/thirdparty/TRELLIS/trellis/modules/sparse/norm.py new file mode 100755 index 0000000000000000000000000000000000000000..6b38a36682c098210000dc31d68ddc31ccd2929d --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/norm.py @@ -0,0 +1,58 @@ +import torch +import torch.nn as nn +from . import SparseTensor +from . import DEBUG + +__all__ = [ + 'SparseGroupNorm', + 'SparseLayerNorm', + 'SparseGroupNorm32', + 'SparseLayerNorm32', +] + + +class SparseGroupNorm(nn.GroupNorm): + def __init__(self, num_groups, num_channels, eps=1e-5, affine=True): + super(SparseGroupNorm, self).__init__(num_groups, num_channels, eps, affine) + + def forward(self, input: SparseTensor) -> SparseTensor: + nfeats = torch.zeros_like(input.feats) + for k in range(input.shape[0]): + if DEBUG: + assert (input.coords[input.layout[k], 0] == k).all(), f"SparseGroupNorm: batch index mismatch" + bfeats = input.feats[input.layout[k]] + bfeats = bfeats.permute(1, 0).reshape(1, input.shape[1], -1) + bfeats = super().forward(bfeats) + bfeats = bfeats.reshape(input.shape[1], -1).permute(1, 0) + nfeats[input.layout[k]] = bfeats + return input.replace(nfeats) + + +class SparseLayerNorm(nn.LayerNorm): + def __init__(self, normalized_shape, eps=1e-5, elementwise_affine=True): + super(SparseLayerNorm, self).__init__(normalized_shape, eps, elementwise_affine) + + def forward(self, input: SparseTensor) -> SparseTensor: + nfeats = torch.zeros_like(input.feats) + for k in range(input.shape[0]): + bfeats = input.feats[input.layout[k]] + bfeats = bfeats.permute(1, 0).reshape(1, input.shape[1], -1) + bfeats = super().forward(bfeats) + bfeats = bfeats.reshape(input.shape[1], -1).permute(1, 0) + nfeats[input.layout[k]] = bfeats + return input.replace(nfeats) + + +class SparseGroupNorm32(SparseGroupNorm): + """ + A GroupNorm layer that converts to float32 before the forward pass. + """ + def forward(self, x: SparseTensor) -> SparseTensor: + return super().forward(x.float()).type(x.dtype) + +class SparseLayerNorm32(SparseLayerNorm): + """ + A LayerNorm layer that converts to float32 before the forward pass. + """ + def forward(self, x: SparseTensor) -> SparseTensor: + return super().forward(x.float()).type(x.dtype) diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/spatial.py b/thirdparty/TRELLIS/trellis/modules/sparse/spatial.py new file mode 100755 index 0000000000000000000000000000000000000000..ad7121473f335b307e2f7ea5f05c964d3aec0440 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/spatial.py @@ -0,0 +1,110 @@ +from typing import * +import torch +import torch.nn as nn +from . import SparseTensor + +__all__ = [ + 'SparseDownsample', + 'SparseUpsample', + 'SparseSubdivide' +] + + +class SparseDownsample(nn.Module): + """ + Downsample a sparse tensor by a factor of `factor`. + Implemented as average pooling. + """ + def __init__(self, factor: Union[int, Tuple[int, ...], List[int]]): + super(SparseDownsample, self).__init__() + self.factor = tuple(factor) if isinstance(factor, (list, tuple)) else factor + + def forward(self, input: SparseTensor) -> SparseTensor: + DIM = input.coords.shape[-1] - 1 + factor = self.factor if isinstance(self.factor, tuple) else (self.factor,) * DIM + assert DIM == len(factor), 'Input coordinates must have the same dimension as the downsample factor.' + + coord = list(input.coords.unbind(dim=-1)) + for i, f in enumerate(factor): + coord[i+1] = coord[i+1] // f + + MAX = [coord[i+1].max().item() + 1 for i in range(DIM)] + OFFSET = torch.cumprod(torch.tensor(MAX[::-1]), 0).tolist()[::-1] + [1] + code = sum([c * o for c, o in zip(coord, OFFSET)]) + code, idx = code.unique(return_inverse=True) + + new_feats = torch.scatter_reduce( + torch.zeros(code.shape[0], input.feats.shape[1], device=input.feats.device, dtype=input.feats.dtype), + dim=0, + index=idx.unsqueeze(1).expand(-1, input.feats.shape[1]), + src=input.feats, + reduce='mean' + ) + new_coords = torch.stack( + [code // OFFSET[0]] + + [(code // OFFSET[i+1]) % MAX[i] for i in range(DIM)], + dim=-1 + ) + out = SparseTensor(new_feats, new_coords, input.shape,) + out._scale = tuple([s // f for s, f in zip(input._scale, factor)]) + out._spatial_cache = input._spatial_cache + + out.register_spatial_cache(f'upsample_{factor}_coords', input.coords) + out.register_spatial_cache(f'upsample_{factor}_layout', input.layout) + out.register_spatial_cache(f'upsample_{factor}_idx', idx) + + return out + + +class SparseUpsample(nn.Module): + """ + Upsample a sparse tensor by a factor of `factor`. + Implemented as nearest neighbor interpolation. + """ + def __init__(self, factor: Union[int, Tuple[int, int, int], List[int]]): + super(SparseUpsample, self).__init__() + self.factor = tuple(factor) if isinstance(factor, (list, tuple)) else factor + + def forward(self, input: SparseTensor) -> SparseTensor: + DIM = input.coords.shape[-1] - 1 + factor = self.factor if isinstance(self.factor, tuple) else (self.factor,) * DIM + assert DIM == len(factor), 'Input coordinates must have the same dimension as the upsample factor.' + + new_coords = input.get_spatial_cache(f'upsample_{factor}_coords') + new_layout = input.get_spatial_cache(f'upsample_{factor}_layout') + idx = input.get_spatial_cache(f'upsample_{factor}_idx') + if any([x is None for x in [new_coords, new_layout, idx]]): + raise ValueError('Upsample cache not found. SparseUpsample must be paired with SparseDownsample.') + new_feats = input.feats[idx] + out = SparseTensor(new_feats, new_coords, input.shape, new_layout) + out._scale = tuple([s * f for s, f in zip(input._scale, factor)]) + out._spatial_cache = input._spatial_cache + return out + +class SparseSubdivide(nn.Module): + """ + Upsample a sparse tensor by a factor of `factor`. + Implemented as nearest neighbor interpolation. + """ + def __init__(self): + super(SparseSubdivide, self).__init__() + + def forward(self, input: SparseTensor) -> SparseTensor: + DIM = input.coords.shape[-1] - 1 + # upsample scale=2^DIM + n_cube = torch.ones([2] * DIM, device=input.device, dtype=torch.int) + n_coords = torch.nonzero(n_cube) + n_coords = torch.cat([torch.zeros_like(n_coords[:, :1]), n_coords], dim=-1) + factor = n_coords.shape[0] + assert factor == 2 ** DIM + # print(n_coords.shape) + new_coords = input.coords.clone() + new_coords[:, 1:] *= 2 + new_coords = new_coords.unsqueeze(1) + n_coords.unsqueeze(0).to(new_coords.dtype) + + new_feats = input.feats.unsqueeze(1).expand(input.feats.shape[0], factor, *input.feats.shape[1:]) + out = SparseTensor(new_feats.flatten(0, 1), new_coords.flatten(0, 1), input.shape) + out._scale = input._scale * 2 + out._spatial_cache = input._spatial_cache + return out + diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/transformer/__init__.py b/thirdparty/TRELLIS/trellis/modules/sparse/transformer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b08b0d4e5bc24060a2cdc8df75d06dce122972bd --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/transformer/__init__.py @@ -0,0 +1,2 @@ +from .blocks import * +from .modulated import * \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/transformer/blocks.py b/thirdparty/TRELLIS/trellis/modules/sparse/transformer/blocks.py new file mode 100644 index 0000000000000000000000000000000000000000..9d037a49bf83e1c2dfb2f8c4b23d2e9d6c51e9f0 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/transformer/blocks.py @@ -0,0 +1,151 @@ +from typing import * +import torch +import torch.nn as nn +from ..basic import SparseTensor +from ..linear import SparseLinear +from ..nonlinearity import SparseGELU +from ..attention import SparseMultiHeadAttention, SerializeMode +from ...norm import LayerNorm32 + + +class SparseFeedForwardNet(nn.Module): + def __init__(self, channels: int, mlp_ratio: float = 4.0): + super().__init__() + self.mlp = nn.Sequential( + SparseLinear(channels, int(channels * mlp_ratio)), + SparseGELU(approximate="tanh"), + SparseLinear(int(channels * mlp_ratio), channels), + ) + + def forward(self, x: SparseTensor) -> SparseTensor: + return self.mlp(x) + + +class SparseTransformerBlock(nn.Module): + """ + Sparse Transformer block (MSA + FFN). + """ + def __init__( + self, + channels: int, + num_heads: int, + mlp_ratio: float = 4.0, + attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full", + window_size: Optional[int] = None, + shift_sequence: Optional[int] = None, + shift_window: Optional[Tuple[int, int, int]] = None, + serialize_mode: Optional[SerializeMode] = None, + use_checkpoint: bool = False, + use_rope: bool = False, + qk_rms_norm: bool = False, + qkv_bias: bool = True, + ln_affine: bool = False, + ): + super().__init__() + self.use_checkpoint = use_checkpoint + self.norm1 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6) + self.norm2 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6) + self.attn = SparseMultiHeadAttention( + channels, + num_heads=num_heads, + attn_mode=attn_mode, + window_size=window_size, + shift_sequence=shift_sequence, + shift_window=shift_window, + serialize_mode=serialize_mode, + qkv_bias=qkv_bias, + use_rope=use_rope, + qk_rms_norm=qk_rms_norm, + ) + self.mlp = SparseFeedForwardNet( + channels, + mlp_ratio=mlp_ratio, + ) + + def _forward(self, x: SparseTensor) -> SparseTensor: + h = x.replace(self.norm1(x.feats)) + h = self.attn(h) + x = x + h + h = x.replace(self.norm2(x.feats)) + h = self.mlp(h) + x = x + h + return x + + def forward(self, x: SparseTensor) -> SparseTensor: + if self.use_checkpoint: + return torch.utils.checkpoint.checkpoint(self._forward, x, use_reentrant=False) + else: + return self._forward(x) + + +class SparseTransformerCrossBlock(nn.Module): + """ + Sparse Transformer cross-attention block (MSA + MCA + FFN). + """ + def __init__( + self, + channels: int, + ctx_channels: int, + num_heads: int, + mlp_ratio: float = 4.0, + attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full", + window_size: Optional[int] = None, + shift_sequence: Optional[int] = None, + shift_window: Optional[Tuple[int, int, int]] = None, + serialize_mode: Optional[SerializeMode] = None, + use_checkpoint: bool = False, + use_rope: bool = False, + qk_rms_norm: bool = False, + qk_rms_norm_cross: bool = False, + qkv_bias: bool = True, + ln_affine: bool = False, + ): + super().__init__() + self.use_checkpoint = use_checkpoint + self.norm1 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6) + self.norm2 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6) + self.norm3 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6) + self.self_attn = SparseMultiHeadAttention( + channels, + num_heads=num_heads, + type="self", + attn_mode=attn_mode, + window_size=window_size, + shift_sequence=shift_sequence, + shift_window=shift_window, + serialize_mode=serialize_mode, + qkv_bias=qkv_bias, + use_rope=use_rope, + qk_rms_norm=qk_rms_norm, + ) + self.cross_attn = SparseMultiHeadAttention( + channels, + ctx_channels=ctx_channels, + num_heads=num_heads, + type="cross", + attn_mode="full", + qkv_bias=qkv_bias, + qk_rms_norm=qk_rms_norm_cross, + ) + self.mlp = SparseFeedForwardNet( + channels, + mlp_ratio=mlp_ratio, + ) + + def _forward(self, x: SparseTensor, mod: torch.Tensor, context: torch.Tensor): + h = x.replace(self.norm1(x.feats)) + h = self.self_attn(h) + x = x + h + h = x.replace(self.norm2(x.feats)) + h = self.cross_attn(h, context) + x = x + h + h = x.replace(self.norm3(x.feats)) + h = self.mlp(h) + x = x + h + return x + + def forward(self, x: SparseTensor, context: torch.Tensor): + if self.use_checkpoint: + return torch.utils.checkpoint.checkpoint(self._forward, x, context, use_reentrant=False) + else: + return self._forward(x, context) diff --git a/thirdparty/TRELLIS/trellis/modules/sparse/transformer/modulated.py b/thirdparty/TRELLIS/trellis/modules/sparse/transformer/modulated.py new file mode 100644 index 0000000000000000000000000000000000000000..4a8416559f39acbed9e5996e9891c97f95c80c8f --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/sparse/transformer/modulated.py @@ -0,0 +1,166 @@ +from typing import * +import torch +import torch.nn as nn +from ..basic import SparseTensor +from ..attention import SparseMultiHeadAttention, SerializeMode +from ...norm import LayerNorm32 +from .blocks import SparseFeedForwardNet + + +class ModulatedSparseTransformerBlock(nn.Module): + """ + Sparse Transformer block (MSA + FFN) with adaptive layer norm conditioning. + """ + def __init__( + self, + channels: int, + num_heads: int, + mlp_ratio: float = 4.0, + attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full", + window_size: Optional[int] = None, + shift_sequence: Optional[int] = None, + shift_window: Optional[Tuple[int, int, int]] = None, + serialize_mode: Optional[SerializeMode] = None, + use_checkpoint: bool = False, + use_rope: bool = False, + qk_rms_norm: bool = False, + qkv_bias: bool = True, + share_mod: bool = False, + ): + super().__init__() + self.use_checkpoint = use_checkpoint + self.share_mod = share_mod + self.norm1 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6) + self.norm2 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6) + self.attn = SparseMultiHeadAttention( + channels, + num_heads=num_heads, + attn_mode=attn_mode, + window_size=window_size, + shift_sequence=shift_sequence, + shift_window=shift_window, + serialize_mode=serialize_mode, + qkv_bias=qkv_bias, + use_rope=use_rope, + qk_rms_norm=qk_rms_norm, + ) + self.mlp = SparseFeedForwardNet( + channels, + mlp_ratio=mlp_ratio, + ) + if not share_mod: + self.adaLN_modulation = nn.Sequential( + nn.SiLU(), + nn.Linear(channels, 6 * channels, bias=True) + ) + + def _forward(self, x: SparseTensor, mod: torch.Tensor) -> SparseTensor: + if self.share_mod: + shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = mod.chunk(6, dim=1) + else: + shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(mod).chunk(6, dim=1) + h = x.replace(self.norm1(x.feats)) + h = h * (1 + scale_msa) + shift_msa + h = self.attn(h) + h = h * gate_msa + x = x + h + h = x.replace(self.norm2(x.feats)) + h = h * (1 + scale_mlp) + shift_mlp + h = self.mlp(h) + h = h * gate_mlp + x = x + h + return x + + def forward(self, x: SparseTensor, mod: torch.Tensor) -> SparseTensor: + if self.use_checkpoint: + return torch.utils.checkpoint.checkpoint(self._forward, x, mod, use_reentrant=False) + else: + return self._forward(x, mod) + + +class ModulatedSparseTransformerCrossBlock(nn.Module): + """ + Sparse Transformer cross-attention block (MSA + MCA + FFN) with adaptive layer norm conditioning. + """ + def __init__( + self, + channels: int, + ctx_channels: int, + num_heads: int, + mlp_ratio: float = 4.0, + attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full", + window_size: Optional[int] = None, + shift_sequence: Optional[int] = None, + shift_window: Optional[Tuple[int, int, int]] = None, + serialize_mode: Optional[SerializeMode] = None, + use_checkpoint: bool = False, + use_rope: bool = False, + qk_rms_norm: bool = False, + qk_rms_norm_cross: bool = False, + qkv_bias: bool = True, + share_mod: bool = False, + + ): + super().__init__() + self.use_checkpoint = use_checkpoint + self.share_mod = share_mod + self.norm1 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6) + self.norm2 = LayerNorm32(channels, elementwise_affine=True, eps=1e-6) + self.norm3 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6) + self.self_attn = SparseMultiHeadAttention( + channels, + num_heads=num_heads, + type="self", + attn_mode=attn_mode, + window_size=window_size, + shift_sequence=shift_sequence, + shift_window=shift_window, + serialize_mode=serialize_mode, + qkv_bias=qkv_bias, + use_rope=use_rope, + qk_rms_norm=qk_rms_norm, + ) + self.cross_attn = SparseMultiHeadAttention( + channels, + ctx_channels=ctx_channels, + num_heads=num_heads, + type="cross", + attn_mode="full", + qkv_bias=qkv_bias, + qk_rms_norm=qk_rms_norm_cross, + ) + self.mlp = SparseFeedForwardNet( + channels, + mlp_ratio=mlp_ratio, + ) + if not share_mod: + self.adaLN_modulation = nn.Sequential( + nn.SiLU(), + nn.Linear(channels, 6 * channels, bias=True) + ) + + def _forward(self, x: SparseTensor, mod: torch.Tensor, context: torch.Tensor) -> SparseTensor: + if self.share_mod: + shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = mod.chunk(6, dim=1) + else: + shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(mod).chunk(6, dim=1) + h = x.replace(self.norm1(x.feats)) + h = h * (1 + scale_msa) + shift_msa + h = self.self_attn(h) + h = h * gate_msa + x = x + h + h = x.replace(self.norm2(x.feats)) + h = self.cross_attn(h, context) + x = x + h + h = x.replace(self.norm3(x.feats)) + h = h * (1 + scale_mlp) + shift_mlp + h = self.mlp(h) + h = h * gate_mlp + x = x + h + return x + + def forward(self, x: SparseTensor, mod: torch.Tensor, context: torch.Tensor) -> SparseTensor: + if self.use_checkpoint: + return torch.utils.checkpoint.checkpoint(self._forward, x, mod, context, use_reentrant=False) + else: + return self._forward(x, mod, context) diff --git a/thirdparty/TRELLIS/trellis/modules/spatial.py b/thirdparty/TRELLIS/trellis/modules/spatial.py new file mode 100644 index 0000000000000000000000000000000000000000..79e268d36c2ba49b0275744022a1a1e19983dae3 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/spatial.py @@ -0,0 +1,48 @@ +import torch + + +def pixel_shuffle_3d(x: torch.Tensor, scale_factor: int) -> torch.Tensor: + """ + 3D pixel shuffle. + """ + B, C, H, W, D = x.shape + C_ = C // scale_factor**3 + x = x.reshape(B, C_, scale_factor, scale_factor, scale_factor, H, W, D) + x = x.permute(0, 1, 5, 2, 6, 3, 7, 4) + x = x.reshape(B, C_, H*scale_factor, W*scale_factor, D*scale_factor) + return x + + +def patchify(x: torch.Tensor, patch_size: int): + """ + Patchify a tensor. + + Args: + x (torch.Tensor): (N, C, *spatial) tensor + patch_size (int): Patch size + """ + DIM = x.dim() - 2 + for d in range(2, DIM + 2): + assert x.shape[d] % patch_size == 0, f"Dimension {d} of input tensor must be divisible by patch size, got {x.shape[d]} and {patch_size}" + + x = x.reshape(*x.shape[:2], *sum([[x.shape[d] // patch_size, patch_size] for d in range(2, DIM + 2)], [])) + x = x.permute(0, 1, *([2 * i + 3 for i in range(DIM)] + [2 * i + 2 for i in range(DIM)])) + x = x.reshape(x.shape[0], x.shape[1] * (patch_size ** DIM), *(x.shape[-DIM:])) + return x + + +def unpatchify(x: torch.Tensor, patch_size: int): + """ + Unpatchify a tensor. + + Args: + x (torch.Tensor): (N, C, *spatial) tensor + patch_size (int): Patch size + """ + DIM = x.dim() - 2 + assert x.shape[1] % (patch_size ** DIM) == 0, f"Second dimension of input tensor must be divisible by patch size to unpatchify, got {x.shape[1]} and {patch_size ** DIM}" + + x = x.reshape(x.shape[0], x.shape[1] // (patch_size ** DIM), *([patch_size] * DIM), *(x.shape[-DIM:])) + x = x.permute(0, 1, *(sum([[2 + DIM + i, 2 + i] for i in range(DIM)], []))) + x = x.reshape(x.shape[0], x.shape[1], *[x.shape[2 + 2 * i] * patch_size for i in range(DIM)]) + return x diff --git a/thirdparty/TRELLIS/trellis/modules/transformer/__init__.py b/thirdparty/TRELLIS/trellis/modules/transformer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b08b0d4e5bc24060a2cdc8df75d06dce122972bd --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/transformer/__init__.py @@ -0,0 +1,2 @@ +from .blocks import * +from .modulated import * \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/modules/transformer/blocks.py b/thirdparty/TRELLIS/trellis/modules/transformer/blocks.py new file mode 100644 index 0000000000000000000000000000000000000000..c37eb7ed92f4aacfc9e974a63b247589d95977da --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/transformer/blocks.py @@ -0,0 +1,182 @@ +from typing import * +import torch +import torch.nn as nn +from ..attention import MultiHeadAttention +from ..norm import LayerNorm32 + + +class AbsolutePositionEmbedder(nn.Module): + """ + Embeds spatial positions into vector representations. + """ + def __init__(self, channels: int, in_channels: int = 3): + super().__init__() + self.channels = channels + self.in_channels = in_channels + self.freq_dim = channels // in_channels // 2 + self.freqs = torch.arange(self.freq_dim, dtype=torch.float32) / self.freq_dim + self.freqs = 1.0 / (10000 ** self.freqs) + + def _sin_cos_embedding(self, x: torch.Tensor) -> torch.Tensor: + """ + Create sinusoidal position embeddings. + + Args: + x: a 1-D Tensor of N indices + + Returns: + an (N, D) Tensor of positional embeddings. + """ + self.freqs = self.freqs.to(x.device) + out = torch.outer(x, self.freqs) + out = torch.cat([torch.sin(out), torch.cos(out)], dim=-1) + return out + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """ + Args: + x (torch.Tensor): (N, D) tensor of spatial positions + """ + N, D = x.shape + assert D == self.in_channels, "Input dimension must match number of input channels" + embed = self._sin_cos_embedding(x.reshape(-1)) + embed = embed.reshape(N, -1) + if embed.shape[1] < self.channels: + embed = torch.cat([embed, torch.zeros(N, self.channels - embed.shape[1], device=embed.device)], dim=-1) + return embed + + +class FeedForwardNet(nn.Module): + def __init__(self, channels: int, mlp_ratio: float = 4.0): + super().__init__() + self.mlp = nn.Sequential( + nn.Linear(channels, int(channels * mlp_ratio)), + nn.GELU(approximate="tanh"), + nn.Linear(int(channels * mlp_ratio), channels), + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return self.mlp(x) + + +class TransformerBlock(nn.Module): + """ + Transformer block (MSA + FFN). + """ + def __init__( + self, + channels: int, + num_heads: int, + mlp_ratio: float = 4.0, + attn_mode: Literal["full", "windowed"] = "full", + window_size: Optional[int] = None, + shift_window: Optional[int] = None, + use_checkpoint: bool = False, + use_rope: bool = False, + qk_rms_norm: bool = False, + qkv_bias: bool = True, + ln_affine: bool = False, + ): + super().__init__() + self.use_checkpoint = use_checkpoint + self.norm1 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6) + self.norm2 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6) + self.attn = MultiHeadAttention( + channels, + num_heads=num_heads, + attn_mode=attn_mode, + window_size=window_size, + shift_window=shift_window, + qkv_bias=qkv_bias, + use_rope=use_rope, + qk_rms_norm=qk_rms_norm, + ) + self.mlp = FeedForwardNet( + channels, + mlp_ratio=mlp_ratio, + ) + + def _forward(self, x: torch.Tensor) -> torch.Tensor: + h = self.norm1(x) + h = self.attn(h) + x = x + h + h = self.norm2(x) + h = self.mlp(h) + x = x + h + return x + + def forward(self, x: torch.Tensor) -> torch.Tensor: + if self.use_checkpoint: + return torch.utils.checkpoint.checkpoint(self._forward, x, use_reentrant=False) + else: + return self._forward(x) + + +class TransformerCrossBlock(nn.Module): + """ + Transformer cross-attention block (MSA + MCA + FFN). + """ + def __init__( + self, + channels: int, + ctx_channels: int, + num_heads: int, + mlp_ratio: float = 4.0, + attn_mode: Literal["full", "windowed"] = "full", + window_size: Optional[int] = None, + shift_window: Optional[Tuple[int, int, int]] = None, + use_checkpoint: bool = False, + use_rope: bool = False, + qk_rms_norm: bool = False, + qk_rms_norm_cross: bool = False, + qkv_bias: bool = True, + ln_affine: bool = False, + ): + super().__init__() + self.use_checkpoint = use_checkpoint + self.norm1 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6) + self.norm2 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6) + self.norm3 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6) + self.self_attn = MultiHeadAttention( + channels, + num_heads=num_heads, + type="self", + attn_mode=attn_mode, + window_size=window_size, + shift_window=shift_window, + qkv_bias=qkv_bias, + use_rope=use_rope, + qk_rms_norm=qk_rms_norm, + ) + self.cross_attn = MultiHeadAttention( + channels, + ctx_channels=ctx_channels, + num_heads=num_heads, + type="cross", + attn_mode="full", + qkv_bias=qkv_bias, + qk_rms_norm=qk_rms_norm_cross, + ) + self.mlp = FeedForwardNet( + channels, + mlp_ratio=mlp_ratio, + ) + + def _forward(self, x: torch.Tensor, context: torch.Tensor): + h = self.norm1(x) + h = self.self_attn(h) + x = x + h + h = self.norm2(x) + h = self.cross_attn(h, context) + x = x + h + h = self.norm3(x) + h = self.mlp(h) + x = x + h + return x + + def forward(self, x: torch.Tensor, context: torch.Tensor): + if self.use_checkpoint: + return torch.utils.checkpoint.checkpoint(self._forward, x, context, use_reentrant=False) + else: + return self._forward(x, context) + \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/modules/transformer/modulated.py b/thirdparty/TRELLIS/trellis/modules/transformer/modulated.py new file mode 100644 index 0000000000000000000000000000000000000000..d4aeca0689e68f656b08f7aa822b7be839aa727d --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/transformer/modulated.py @@ -0,0 +1,157 @@ +from typing import * +import torch +import torch.nn as nn +from ..attention import MultiHeadAttention +from ..norm import LayerNorm32 +from .blocks import FeedForwardNet + + +class ModulatedTransformerBlock(nn.Module): + """ + Transformer block (MSA + FFN) with adaptive layer norm conditioning. + """ + def __init__( + self, + channels: int, + num_heads: int, + mlp_ratio: float = 4.0, + attn_mode: Literal["full", "windowed"] = "full", + window_size: Optional[int] = None, + shift_window: Optional[Tuple[int, int, int]] = None, + use_checkpoint: bool = False, + use_rope: bool = False, + qk_rms_norm: bool = False, + qkv_bias: bool = True, + share_mod: bool = False, + ): + super().__init__() + self.use_checkpoint = use_checkpoint + self.share_mod = share_mod + self.norm1 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6) + self.norm2 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6) + self.attn = MultiHeadAttention( + channels, + num_heads=num_heads, + attn_mode=attn_mode, + window_size=window_size, + shift_window=shift_window, + qkv_bias=qkv_bias, + use_rope=use_rope, + qk_rms_norm=qk_rms_norm, + ) + self.mlp = FeedForwardNet( + channels, + mlp_ratio=mlp_ratio, + ) + if not share_mod: + self.adaLN_modulation = nn.Sequential( + nn.SiLU(), + nn.Linear(channels, 6 * channels, bias=True) + ) + + def _forward(self, x: torch.Tensor, mod: torch.Tensor) -> torch.Tensor: + if self.share_mod: + shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = mod.chunk(6, dim=1) + else: + shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(mod).chunk(6, dim=1) + h = self.norm1(x) + h = h * (1 + scale_msa.unsqueeze(1)) + shift_msa.unsqueeze(1) + h = self.attn(h) + h = h * gate_msa.unsqueeze(1) + x = x + h + h = self.norm2(x) + h = h * (1 + scale_mlp.unsqueeze(1)) + shift_mlp.unsqueeze(1) + h = self.mlp(h) + h = h * gate_mlp.unsqueeze(1) + x = x + h + return x + + def forward(self, x: torch.Tensor, mod: torch.Tensor) -> torch.Tensor: + if self.use_checkpoint: + return torch.utils.checkpoint.checkpoint(self._forward, x, mod, use_reentrant=False) + else: + return self._forward(x, mod) + + +class ModulatedTransformerCrossBlock(nn.Module): + """ + Transformer cross-attention block (MSA + MCA + FFN) with adaptive layer norm conditioning. + """ + def __init__( + self, + channels: int, + ctx_channels: int, + num_heads: int, + mlp_ratio: float = 4.0, + attn_mode: Literal["full", "windowed"] = "full", + window_size: Optional[int] = None, + shift_window: Optional[Tuple[int, int, int]] = None, + use_checkpoint: bool = False, + use_rope: bool = False, + qk_rms_norm: bool = False, + qk_rms_norm_cross: bool = False, + qkv_bias: bool = True, + share_mod: bool = False, + ): + super().__init__() + self.use_checkpoint = use_checkpoint + self.share_mod = share_mod + self.norm1 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6) + self.norm2 = LayerNorm32(channels, elementwise_affine=True, eps=1e-6) + self.norm3 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6) + self.self_attn = MultiHeadAttention( + channels, + num_heads=num_heads, + type="self", + attn_mode=attn_mode, + window_size=window_size, + shift_window=shift_window, + qkv_bias=qkv_bias, + use_rope=use_rope, + qk_rms_norm=qk_rms_norm, + ) + self.cross_attn = MultiHeadAttention( + channels, + ctx_channels=ctx_channels, + num_heads=num_heads, + type="cross", + attn_mode="full", + qkv_bias=qkv_bias, + qk_rms_norm=qk_rms_norm_cross, + ) + self.mlp = FeedForwardNet( + channels, + mlp_ratio=mlp_ratio, + ) + if not share_mod: + self.adaLN_modulation = nn.Sequential( + nn.SiLU(), + nn.Linear(channels, 6 * channels, bias=True) + ) + + def _forward(self, x: torch.Tensor, mod: torch.Tensor, context: torch.Tensor): + if self.share_mod: + shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = mod.chunk(6, dim=1) + else: + shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(mod).chunk(6, dim=1) + h = self.norm1(x) + h = h * (1 + scale_msa.unsqueeze(1)) + shift_msa.unsqueeze(1) + h = self.self_attn(h) + h = h * gate_msa.unsqueeze(1) + x = x + h + h = self.norm2(x) + h = self.cross_attn(h, context) + x = x + h + h = self.norm3(x) + h = h * (1 + scale_mlp.unsqueeze(1)) + shift_mlp.unsqueeze(1) + h = self.mlp(h) + h = h * gate_mlp.unsqueeze(1) + x = x + h + return x + + def forward(self, x: torch.Tensor, mod: torch.Tensor, context: torch.Tensor): + if self.use_checkpoint: + return torch.utils.checkpoint.checkpoint(self._forward, x, mod, context, use_reentrant=False) + else: + return self._forward(x, mod, context) + \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/modules/utils.py b/thirdparty/TRELLIS/trellis/modules/utils.py new file mode 100755 index 0000000000000000000000000000000000000000..f0afb1b6c767aa2ad00bad96649fb30315e696ea --- /dev/null +++ b/thirdparty/TRELLIS/trellis/modules/utils.py @@ -0,0 +1,54 @@ +import torch.nn as nn +from ..modules import sparse as sp + +FP16_MODULES = ( + nn.Conv1d, + nn.Conv2d, + nn.Conv3d, + nn.ConvTranspose1d, + nn.ConvTranspose2d, + nn.ConvTranspose3d, + nn.Linear, + sp.SparseConv3d, + sp.SparseInverseConv3d, + sp.SparseLinear, +) + +def convert_module_to_f16(l): + """ + Convert primitive modules to float16. + """ + if isinstance(l, FP16_MODULES): + for p in l.parameters(): + p.data = p.data.half() + + +def convert_module_to_f32(l): + """ + Convert primitive modules to float32, undoing convert_module_to_f16(). + """ + if isinstance(l, FP16_MODULES): + for p in l.parameters(): + p.data = p.data.float() + + +def zero_module(module): + """ + Zero out the parameters of a module and return it. + """ + for p in module.parameters(): + p.detach().zero_() + return module + + +def scale_module(module, scale): + """ + Scale the parameters of a module and return it. + """ + for p in module.parameters(): + p.detach().mul_(scale) + return module + + +def modulate(x, shift, scale): + return x * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1) diff --git a/thirdparty/TRELLIS/trellis/pipelines/__init__.py b/thirdparty/TRELLIS/trellis/pipelines/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f9e8548b894aeb3d354c739320ed3288be9c7b0e --- /dev/null +++ b/thirdparty/TRELLIS/trellis/pipelines/__init__.py @@ -0,0 +1,24 @@ +from . import samplers +from .trellis_image_to_3d import TrellisImageTo3DPipeline + + +def from_pretrained(path: str): + """ + Load a pipeline from a model folder or a Hugging Face model hub. + + Args: + path: The path to the model. Can be either local path or a Hugging Face model name. + """ + import os + import json + is_local = os.path.exists(f"{path}/pipeline.json") + + if is_local: + config_file = f"{path}/pipeline.json" + else: + from huggingface_hub import hf_hub_download + config_file = hf_hub_download(path, "pipeline.json") + + with open(config_file, 'r') as f: + config = json.load(f) + return globals()[config['name']].from_pretrained(path) diff --git a/thirdparty/TRELLIS/trellis/pipelines/base.py b/thirdparty/TRELLIS/trellis/pipelines/base.py new file mode 100644 index 0000000000000000000000000000000000000000..3a9e0df4ec5fb915d57d30189cac854e3f095620 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/pipelines/base.py @@ -0,0 +1,66 @@ +from typing import * +import torch +import torch.nn as nn +from .. import models + + +class Pipeline: + """ + A base class for pipelines. + """ + def __init__( + self, + models: dict[str, nn.Module] = None, + ): + if models is None: + return + self.models = models + for model in self.models.values(): + model.eval() + + @staticmethod + def from_pretrained(path: str) -> "Pipeline": + """ + Load a pretrained model. + """ + import os + import json + is_local = os.path.exists(f"{path}/pipeline.json") + + if is_local: + config_file = f"{path}/pipeline.json" + else: + from huggingface_hub import hf_hub_download + config_file = hf_hub_download(path, "pipeline.json") + + with open(config_file, 'r') as f: + args = json.load(f)['args'] + + _models = { + k: models.from_pretrained(f"{path}/{v}") + for k, v in args['models'].items() + } + + new_pipeline = Pipeline(_models) + new_pipeline._pretrained_args = args + return new_pipeline + + @property + def device(self) -> torch.device: + for model in self.models.values(): + if hasattr(model, 'device'): + return model.device + for model in self.models.values(): + if hasattr(model, 'parameters'): + return next(model.parameters()).device + raise RuntimeError("No device found.") + + def to(self, device: torch.device) -> None: + for model in self.models.values(): + model.to(device) + + def cuda(self) -> None: + self.to(torch.device("cuda")) + + def cpu(self) -> None: + self.to(torch.device("cpu")) diff --git a/thirdparty/TRELLIS/trellis/pipelines/samplers/__init__.py b/thirdparty/TRELLIS/trellis/pipelines/samplers/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..54d412fc5d8eb662081a92a56ad078243988c2f9 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/pipelines/samplers/__init__.py @@ -0,0 +1,2 @@ +from .base import Sampler +from .flow_euler import FlowEulerSampler, FlowEulerCfgSampler, FlowEulerGuidanceIntervalSampler \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/pipelines/samplers/base.py b/thirdparty/TRELLIS/trellis/pipelines/samplers/base.py new file mode 100644 index 0000000000000000000000000000000000000000..1966ce787009a5ee0c1ed06dce491525ff1dbcbf --- /dev/null +++ b/thirdparty/TRELLIS/trellis/pipelines/samplers/base.py @@ -0,0 +1,20 @@ +from typing import * +from abc import ABC, abstractmethod + + +class Sampler(ABC): + """ + A base class for samplers. + """ + + @abstractmethod + def sample( + self, + model, + **kwargs + ): + """ + Sample from a model. + """ + pass + \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/pipelines/samplers/classifier_free_guidance_mixin.py b/thirdparty/TRELLIS/trellis/pipelines/samplers/classifier_free_guidance_mixin.py new file mode 100644 index 0000000000000000000000000000000000000000..5701b25f5d7a2197612eb256f8ee13e8c489da1f --- /dev/null +++ b/thirdparty/TRELLIS/trellis/pipelines/samplers/classifier_free_guidance_mixin.py @@ -0,0 +1,12 @@ +from typing import * + + +class ClassifierFreeGuidanceSamplerMixin: + """ + A mixin class for samplers that apply classifier-free guidance. + """ + + def _inference_model(self, model, x_t, t, cond, neg_cond, cfg_strength, **kwargs): + pred = super()._inference_model(model, x_t, t, cond, **kwargs) + neg_pred = super()._inference_model(model, x_t, t, neg_cond, **kwargs) + return (1 + cfg_strength) * pred - cfg_strength * neg_pred diff --git a/thirdparty/TRELLIS/trellis/pipelines/samplers/flow_euler.py b/thirdparty/TRELLIS/trellis/pipelines/samplers/flow_euler.py new file mode 100644 index 0000000000000000000000000000000000000000..d79124cf1b07515e8f0b88684e271028b1e3a71d --- /dev/null +++ b/thirdparty/TRELLIS/trellis/pipelines/samplers/flow_euler.py @@ -0,0 +1,199 @@ +from typing import * +import torch +import numpy as np +from tqdm import tqdm +from easydict import EasyDict as edict +from .base import Sampler +from .classifier_free_guidance_mixin import ClassifierFreeGuidanceSamplerMixin +from .guidance_interval_mixin import GuidanceIntervalSamplerMixin + + +class FlowEulerSampler(Sampler): + """ + Generate samples from a flow-matching model using Euler sampling. + + Args: + sigma_min: The minimum scale of noise in flow. + """ + def __init__( + self, + sigma_min: float, + ): + self.sigma_min = sigma_min + + def _eps_to_xstart(self, x_t, t, eps): + assert x_t.shape == eps.shape + return (x_t - (self.sigma_min + (1 - self.sigma_min) * t) * eps) / (1 - t) + + def _xstart_to_eps(self, x_t, t, x_0): + assert x_t.shape == x_0.shape + return (x_t - (1 - t) * x_0) / (self.sigma_min + (1 - self.sigma_min) * t) + + def _v_to_xstart_eps(self, x_t, t, v): + assert x_t.shape == v.shape + eps = (1 - t) * v + x_t + x_0 = (1 - self.sigma_min) * x_t - (self.sigma_min + (1 - self.sigma_min) * t) * v + return x_0, eps + + def _inference_model(self, model, x_t, t, cond=None, **kwargs): + t = torch.tensor([1000 * t] * x_t.shape[0], device=x_t.device, dtype=torch.float32) + return model(x_t, t, cond, **kwargs) + + def _get_model_prediction(self, model, x_t, t, cond=None, **kwargs): + pred_v = self._inference_model(model, x_t, t, cond, **kwargs) + pred_x_0, pred_eps = self._v_to_xstart_eps(x_t=x_t, t=t, v=pred_v) + return pred_x_0, pred_eps, pred_v + + @torch.no_grad() + def sample_once( + self, + model, + x_t, + t: float, + t_prev: float, + cond: Optional[Any] = None, + **kwargs + ): + """ + Sample x_{t-1} from the model using Euler method. + + Args: + model: The model to sample from. + x_t: The [N x C x ...] tensor of noisy inputs at time t. + t: The current timestep. + t_prev: The previous timestep. + cond: conditional information. + **kwargs: Additional arguments for model inference. + + Returns: + a dict containing the following + - 'pred_x_prev': x_{t-1}. + - 'pred_x_0': a prediction of x_0. + """ + pred_x_0, pred_eps, pred_v = self._get_model_prediction(model, x_t, t, cond, **kwargs) + pred_x_prev = x_t - (t - t_prev) * pred_v + return edict({"pred_x_prev": pred_x_prev, "pred_x_0": pred_x_0}) + + @torch.no_grad() + def sample( + self, + model, + noise, + cond: Optional[Any] = None, + steps: int = 50, + rescale_t: float = 1.0, + verbose: bool = True, + **kwargs + ): + """ + Generate samples from the model using Euler method. + + Args: + model: The model to sample from. + noise: The initial noise tensor. + cond: conditional information. + steps: The number of steps to sample. + rescale_t: The rescale factor for t. + verbose: If True, show a progress bar. + **kwargs: Additional arguments for model_inference. + + Returns: + a dict containing the following + - 'samples': the model samples. + - 'pred_x_t': a list of prediction of x_t. + - 'pred_x_0': a list of prediction of x_0. + """ + sample = noise + t_seq = np.linspace(1, 0, steps + 1) + t_seq = rescale_t * t_seq / (1 + (rescale_t - 1) * t_seq) + t_pairs = list((t_seq[i], t_seq[i + 1]) for i in range(steps)) + ret = edict({"samples": None, "pred_x_t": [], "pred_x_0": []}) + for t, t_prev in tqdm(t_pairs, desc="Sampling", disable=not verbose): + out = self.sample_once(model, sample, t, t_prev, cond, **kwargs) + sample = out.pred_x_prev + ret.pred_x_t.append(out.pred_x_prev) + ret.pred_x_0.append(out.pred_x_0) + ret.samples = sample + return ret + + +class FlowEulerCfgSampler(ClassifierFreeGuidanceSamplerMixin, FlowEulerSampler): + """ + Generate samples from a flow-matching model using Euler sampling with classifier-free guidance. + """ + @torch.no_grad() + def sample( + self, + model, + noise, + cond, + neg_cond, + steps: int = 50, + rescale_t: float = 1.0, + cfg_strength: float = 3.0, + verbose: bool = True, + **kwargs + ): + """ + Generate samples from the model using Euler method. + + Args: + model: The model to sample from. + noise: The initial noise tensor. + cond: conditional information. + neg_cond: negative conditional information. + steps: The number of steps to sample. + rescale_t: The rescale factor for t. + cfg_strength: The strength of classifier-free guidance. + verbose: If True, show a progress bar. + **kwargs: Additional arguments for model_inference. + + Returns: + a dict containing the following + - 'samples': the model samples. + - 'pred_x_t': a list of prediction of x_t. + - 'pred_x_0': a list of prediction of x_0. + """ + return super().sample(model, noise, cond, steps, rescale_t, verbose, neg_cond=neg_cond, cfg_strength=cfg_strength, **kwargs) + + +class FlowEulerGuidanceIntervalSampler(GuidanceIntervalSamplerMixin, FlowEulerSampler): + """ + Generate samples from a flow-matching model using Euler sampling with classifier-free guidance and interval. + """ + @torch.no_grad() + def sample( + self, + model, + noise, + cond, + neg_cond, + steps: int = 50, + rescale_t: float = 1.0, + cfg_strength: float = 3.0, + cfg_interval: Tuple[float, float] = (0.0, 1.0), + verbose: bool = True, + **kwargs + ): + """ + Generate samples from the model using Euler method. + + Args: + model: The model to sample from. + noise: The initial noise tensor. + cond: conditional information. + neg_cond: negative conditional information. + steps: The number of steps to sample. + rescale_t: The rescale factor for t. + cfg_strength: The strength of classifier-free guidance. + cfg_interval: The interval for classifier-free guidance. + verbose: If True, show a progress bar. + **kwargs: Additional arguments for model_inference. + + Returns: + a dict containing the following + - 'samples': the model samples. + - 'pred_x_t': a list of prediction of x_t. + - 'pred_x_0': a list of prediction of x_0. + """ + return super().sample(model, noise, cond, steps, rescale_t, verbose, neg_cond=neg_cond, cfg_strength=cfg_strength, cfg_interval=cfg_interval, **kwargs) diff --git a/thirdparty/TRELLIS/trellis/pipelines/samplers/guidance_interval_mixin.py b/thirdparty/TRELLIS/trellis/pipelines/samplers/guidance_interval_mixin.py new file mode 100644 index 0000000000000000000000000000000000000000..7074a4d5fea20a8f799416aa6571faca4f9eea06 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/pipelines/samplers/guidance_interval_mixin.py @@ -0,0 +1,15 @@ +from typing import * + + +class GuidanceIntervalSamplerMixin: + """ + A mixin class for samplers that apply classifier-free guidance with interval. + """ + + def _inference_model(self, model, x_t, t, cond, neg_cond, cfg_strength, cfg_interval, **kwargs): + if cfg_interval[0] <= t <= cfg_interval[1]: + pred = super()._inference_model(model, x_t, t, cond, **kwargs) + neg_pred = super()._inference_model(model, x_t, t, neg_cond, **kwargs) + return (1 + cfg_strength) * pred - cfg_strength * neg_pred + else: + return super()._inference_model(model, x_t, t, cond, **kwargs) diff --git a/thirdparty/TRELLIS/trellis/pipelines/trellis_image_to_3d.py b/thirdparty/TRELLIS/trellis/pipelines/trellis_image_to_3d.py new file mode 100644 index 0000000000000000000000000000000000000000..f781e3489ab17def756d5cd676b8858b4ba9b156 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/pipelines/trellis_image_to_3d.py @@ -0,0 +1,376 @@ +from typing import * +from contextlib import contextmanager +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +from tqdm import tqdm +from easydict import EasyDict as edict +from torchvision import transforms +from PIL import Image +import rembg +from .base import Pipeline +from . import samplers +from ..modules import sparse as sp +from ..representations import Gaussian, Strivec, MeshExtractResult + + +class TrellisImageTo3DPipeline(Pipeline): + """ + Pipeline for inferring Trellis image-to-3D models. + + Args: + models (dict[str, nn.Module]): The models to use in the pipeline. + sparse_structure_sampler (samplers.Sampler): The sampler for the sparse structure. + slat_sampler (samplers.Sampler): The sampler for the structured latent. + slat_normalization (dict): The normalization parameters for the structured latent. + image_cond_model (str): The name of the image conditioning model. + """ + def __init__( + self, + models: dict[str, nn.Module] = None, + sparse_structure_sampler: samplers.Sampler = None, + slat_sampler: samplers.Sampler = None, + slat_normalization: dict = None, + image_cond_model: str = None, + ): + if models is None: + return + super().__init__(models) + self.sparse_structure_sampler = sparse_structure_sampler + self.slat_sampler = slat_sampler + self.sparse_structure_sampler_params = {} + self.slat_sampler_params = {} + self.slat_normalization = slat_normalization + self.rembg_session = None + self._init_image_cond_model(image_cond_model) + + @staticmethod + def from_pretrained(path: str) -> "TrellisImageTo3DPipeline": + """ + Load a pretrained model. + + Args: + path (str): The path to the model. Can be either local path or a Hugging Face repository. + """ + pipeline = super(TrellisImageTo3DPipeline, TrellisImageTo3DPipeline).from_pretrained(path) + new_pipeline = TrellisImageTo3DPipeline() + new_pipeline.__dict__ = pipeline.__dict__ + args = pipeline._pretrained_args + + new_pipeline.sparse_structure_sampler = getattr(samplers, args['sparse_structure_sampler']['name'])(**args['sparse_structure_sampler']['args']) + new_pipeline.sparse_structure_sampler_params = args['sparse_structure_sampler']['params'] + + new_pipeline.slat_sampler = getattr(samplers, args['slat_sampler']['name'])(**args['slat_sampler']['args']) + new_pipeline.slat_sampler_params = args['slat_sampler']['params'] + + new_pipeline.slat_normalization = args['slat_normalization'] + + new_pipeline._init_image_cond_model(args['image_cond_model']) + + return new_pipeline + + def _init_image_cond_model(self, name: str): + """ + Initialize the image conditioning model. + """ + dinov2_model = torch.hub.load('facebookresearch/dinov2', name, pretrained=True) + dinov2_model.eval() + self.models['image_cond_model'] = dinov2_model + transform = transforms.Compose([ + transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), + ]) + self.image_cond_model_transform = transform + + def preprocess_image(self, input: Image.Image) -> Image.Image: + """ + Preprocess the input image. + """ + # if has alpha channel, use it directly; otherwise, remove background + has_alpha = False + if input.mode == 'RGBA': + alpha = np.array(input)[:, :, 3] + if not np.all(alpha == 255): + has_alpha = True + if has_alpha: + output = input + else: + input = input.convert('RGB') + max_size = max(input.size) + scale = min(1, 1024 / max_size) + if scale < 1: + input = input.resize((int(input.width * scale), int(input.height * scale)), Image.Resampling.LANCZOS) + if getattr(self, 'rembg_session', None) is None: + self.rembg_session = rembg.new_session('u2net') + output = rembg.remove(input, session=self.rembg_session) + output_np = np.array(output) + alpha = output_np[:, :, 3] + bbox = np.argwhere(alpha > 0.8 * 255) + bbox = np.min(bbox[:, 1]), np.min(bbox[:, 0]), np.max(bbox[:, 1]), np.max(bbox[:, 0]) + center = (bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2 + size = max(bbox[2] - bbox[0], bbox[3] - bbox[1]) + size = int(size * 1.2) + bbox = center[0] - size // 2, center[1] - size // 2, center[0] + size // 2, center[1] + size // 2 + output = output.crop(bbox) # type: ignore + output = output.resize((518, 518), Image.Resampling.LANCZOS) + output = np.array(output).astype(np.float32) / 255 + output = output[:, :, :3] * output[:, :, 3:4] + output = Image.fromarray((output * 255).astype(np.uint8)) + return output + + @torch.no_grad() + def encode_image(self, image: Union[torch.Tensor, list[Image.Image]]) -> torch.Tensor: + """ + Encode the image. + + Args: + image (Union[torch.Tensor, list[Image.Image]]): The image to encode + + Returns: + torch.Tensor: The encoded features. + """ + if isinstance(image, torch.Tensor): + assert image.ndim == 4, "Image tensor should be batched (B, C, H, W)" + elif isinstance(image, list): + assert all(isinstance(i, Image.Image) for i in image), "Image list should be list of PIL images" + image = [i.resize((518, 518), Image.LANCZOS) for i in image] + image = [np.array(i.convert('RGB')).astype(np.float32) / 255 for i in image] + image = [torch.from_numpy(i).permute(2, 0, 1).float() for i in image] + image = torch.stack(image).to(self.device) + else: + raise ValueError(f"Unsupported type of image: {type(image)}") + + image = self.image_cond_model_transform(image).to(self.device) + features = self.models['image_cond_model'](image, is_training=True)['x_prenorm'] + patchtokens = F.layer_norm(features, features.shape[-1:]) + return patchtokens + + def get_cond(self, image: Union[torch.Tensor, list[Image.Image]]) -> dict: + """ + Get the conditioning information for the model. + + Args: + image (Union[torch.Tensor, list[Image.Image]]): The image prompts. + + Returns: + dict: The conditioning information + """ + cond = self.encode_image(image) + neg_cond = torch.zeros_like(cond) + return { + 'cond': cond, + 'neg_cond': neg_cond, + } + + def sample_sparse_structure( + self, + cond: dict, + num_samples: int = 1, + sampler_params: dict = {}, + ) -> torch.Tensor: + """ + Sample sparse structures with the given conditioning. + + Args: + cond (dict): The conditioning information. + num_samples (int): The number of samples to generate. + sampler_params (dict): Additional parameters for the sampler. + """ + # Sample occupancy latent + flow_model = self.models['sparse_structure_flow_model'] + reso = flow_model.resolution + noise = torch.randn(num_samples, flow_model.in_channels, reso, reso, reso).to(self.device) + sampler_params = {**self.sparse_structure_sampler_params, **sampler_params} + z_s = self.sparse_structure_sampler.sample( + flow_model, + noise, + **cond, + **sampler_params, + verbose=True + ).samples + + # Decode occupancy latent + decoder = self.models['sparse_structure_decoder'] + coords = torch.argwhere(decoder(z_s)>0)[:, [0, 2, 3, 4]].int() + + return coords + + def decode_slat( + self, + slat: sp.SparseTensor, + formats: List[str] = ['mesh', 'gaussian', 'radiance_field'], + ) -> dict: + """ + Decode the structured latent. + + Args: + slat (sp.SparseTensor): The structured latent. + formats (List[str]): The formats to decode the structured latent to. + + Returns: + dict: The decoded structured latent. + """ + ret = {} + if 'mesh' in formats: + ret['mesh'] = self.models['slat_decoder_mesh'](slat) + if 'gaussian' in formats: + ret['gaussian'] = self.models['slat_decoder_gs'](slat) + if 'radiance_field' in formats: + ret['radiance_field'] = self.models['slat_decoder_rf'](slat) + return ret + + def sample_slat( + self, + cond: dict, + coords: torch.Tensor, + sampler_params: dict = {}, + ) -> sp.SparseTensor: + """ + Sample structured latent with the given conditioning. + + Args: + cond (dict): The conditioning information. + coords (torch.Tensor): The coordinates of the sparse structure. + sampler_params (dict): Additional parameters for the sampler. + """ + # Sample structured latent + flow_model = self.models['slat_flow_model'] + noise = sp.SparseTensor( + feats=torch.randn(coords.shape[0], flow_model.in_channels).to(self.device), + coords=coords, + ) + sampler_params = {**self.slat_sampler_params, **sampler_params} + slat = self.slat_sampler.sample( + flow_model, + noise, + **cond, + **sampler_params, + verbose=True + ).samples + + std = torch.tensor(self.slat_normalization['std'])[None].to(slat.device) + mean = torch.tensor(self.slat_normalization['mean'])[None].to(slat.device) + slat = slat * std + mean + + return slat + + @torch.no_grad() + def run( + self, + image: Image.Image, + num_samples: int = 1, + seed: int = 42, + sparse_structure_sampler_params: dict = {}, + slat_sampler_params: dict = {}, + formats: List[str] = ['mesh', 'gaussian', 'radiance_field'], + preprocess_image: bool = True, + ) -> dict: + """ + Run the pipeline. + + Args: + image (Image.Image): The image prompt. + num_samples (int): The number of samples to generate. + sparse_structure_sampler_params (dict): Additional parameters for the sparse structure sampler. + slat_sampler_params (dict): Additional parameters for the structured latent sampler. + preprocess_image (bool): Whether to preprocess the image. + """ + if preprocess_image: + image = self.preprocess_image(image) + cond = self.get_cond([image]) + torch.manual_seed(seed) + coords = self.sample_sparse_structure(cond, num_samples, sparse_structure_sampler_params) + slat = self.sample_slat(cond, coords, slat_sampler_params) + return self.decode_slat(slat, formats) + + @contextmanager + def inject_sampler_multi_image( + self, + sampler_name: str, + num_images: int, + num_steps: int, + mode: Literal['stochastic', 'multidiffusion'] = 'stochastic', + ): + """ + Inject a sampler with multiple images as condition. + + Args: + sampler_name (str): The name of the sampler to inject. + num_images (int): The number of images to condition on. + num_steps (int): The number of steps to run the sampler for. + """ + sampler = getattr(self, sampler_name) + setattr(sampler, f'_old_inference_model', sampler._inference_model) + + if mode == 'stochastic': + if num_images > num_steps: + print(f"\033[93mWarning: number of conditioning images is greater than number of steps for {sampler_name}. " + "This may lead to performance degradation.\033[0m") + + cond_indices = (np.arange(num_steps) % num_images).tolist() + def _new_inference_model(self, model, x_t, t, cond, **kwargs): + cond_idx = cond_indices.pop(0) + cond_i = cond[cond_idx:cond_idx+1] + return self._old_inference_model(model, x_t, t, cond=cond_i, **kwargs) + + elif mode =='multidiffusion': + from .samplers import FlowEulerSampler + def _new_inference_model(self, model, x_t, t, cond, neg_cond, cfg_strength, cfg_interval, **kwargs): + if cfg_interval[0] <= t <= cfg_interval[1]: + preds = [] + for i in range(len(cond)): + preds.append(FlowEulerSampler._inference_model(self, model, x_t, t, cond[i:i+1], **kwargs)) + pred = sum(preds) / len(preds) + neg_pred = FlowEulerSampler._inference_model(self, model, x_t, t, neg_cond, **kwargs) + return (1 + cfg_strength) * pred - cfg_strength * neg_pred + else: + preds = [] + for i in range(len(cond)): + preds.append(FlowEulerSampler._inference_model(self, model, x_t, t, cond[i:i+1], **kwargs)) + pred = sum(preds) / len(preds) + return pred + + else: + raise ValueError(f"Unsupported mode: {mode}") + + sampler._inference_model = _new_inference_model.__get__(sampler, type(sampler)) + + yield + + sampler._inference_model = sampler._old_inference_model + delattr(sampler, f'_old_inference_model') + + @torch.no_grad() + def run_multi_image( + self, + images: List[Image.Image], + num_samples: int = 1, + seed: int = 42, + sparse_structure_sampler_params: dict = {}, + slat_sampler_params: dict = {}, + formats: List[str] = ['mesh', 'gaussian', 'radiance_field'], + preprocess_image: bool = True, + mode: Literal['stochastic', 'multidiffusion'] = 'stochastic', + ) -> dict: + """ + Run the pipeline with multiple images as condition + + Args: + images (List[Image.Image]): The multi-view images of the assets + num_samples (int): The number of samples to generate. + sparse_structure_sampler_params (dict): Additional parameters for the sparse structure sampler. + slat_sampler_params (dict): Additional parameters for the structured latent sampler. + preprocess_image (bool): Whether to preprocess the image. + """ + if preprocess_image: + images = [self.preprocess_image(image) for image in images] + cond = self.get_cond(images) + cond['neg_cond'] = cond['neg_cond'][:1] + torch.manual_seed(seed) + ss_steps = {**self.sparse_structure_sampler_params, **sparse_structure_sampler_params}.get('steps') + with self.inject_sampler_multi_image('sparse_structure_sampler', len(images), ss_steps, mode=mode): + coords = self.sample_sparse_structure(cond, num_samples, sparse_structure_sampler_params) + slat_steps = {**self.slat_sampler_params, **slat_sampler_params}.get('steps') + with self.inject_sampler_multi_image('slat_sampler', len(images), slat_steps, mode=mode): + slat = self.sample_slat(cond, coords, slat_sampler_params) + return self.decode_slat(slat, formats) diff --git a/thirdparty/TRELLIS/trellis/renderers/__init__.py b/thirdparty/TRELLIS/trellis/renderers/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..0339355c56b8d17f72e926650d140a658452fbe9 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/renderers/__init__.py @@ -0,0 +1,31 @@ +import importlib + +__attributes = { + 'OctreeRenderer': 'octree_renderer', + 'GaussianRenderer': 'gaussian_render', + 'MeshRenderer': 'mesh_renderer', +} + +__submodules = [] + +__all__ = list(__attributes.keys()) + __submodules + +def __getattr__(name): + if name not in globals(): + if name in __attributes: + module_name = __attributes[name] + module = importlib.import_module(f".{module_name}", __name__) + globals()[name] = getattr(module, name) + elif name in __submodules: + module = importlib.import_module(f".{name}", __name__) + globals()[name] = module + else: + raise AttributeError(f"module {__name__} has no attribute {name}") + return globals()[name] + + +# For Pylance +if __name__ == '__main__': + from .octree_renderer import OctreeRenderer + from .gaussian_render import GaussianRenderer + from .mesh_renderer import MeshRenderer \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/renderers/gaussian_render.py b/thirdparty/TRELLIS/trellis/renderers/gaussian_render.py new file mode 100755 index 0000000000000000000000000000000000000000..57108e3cccf6aab8e3059431557c461de46aff1a --- /dev/null +++ b/thirdparty/TRELLIS/trellis/renderers/gaussian_render.py @@ -0,0 +1,231 @@ +# +# Copyright (C) 2023, Inria +# GRAPHDECO research group, https://team.inria.fr/graphdeco +# All rights reserved. +# +# This software is free for non-commercial, research and evaluation use +# under the terms of the LICENSE.md file. +# +# For inquiries contact george.drettakis@inria.fr +# + +import torch +import math +from easydict import EasyDict as edict +import numpy as np +from ..representations.gaussian import Gaussian +from .sh_utils import eval_sh +import torch.nn.functional as F +from easydict import EasyDict as edict + + +def intrinsics_to_projection( + intrinsics: torch.Tensor, + near: float, + far: float, + ) -> torch.Tensor: + """ + OpenCV intrinsics to OpenGL perspective matrix + + Args: + intrinsics (torch.Tensor): [3, 3] OpenCV intrinsics matrix + near (float): near plane to clip + far (float): far plane to clip + Returns: + (torch.Tensor): [4, 4] OpenGL perspective matrix + """ + fx, fy = intrinsics[0, 0], intrinsics[1, 1] + cx, cy = intrinsics[0, 2], intrinsics[1, 2] + ret = torch.zeros((4, 4), dtype=intrinsics.dtype, device=intrinsics.device) + ret[0, 0] = 2 * fx + ret[1, 1] = 2 * fy + ret[0, 2] = 2 * cx - 1 + ret[1, 2] = - 2 * cy + 1 + ret[2, 2] = far / (far - near) + ret[2, 3] = near * far / (near - far) + ret[3, 2] = 1. + return ret + + +def render(viewpoint_camera, pc : Gaussian, pipe, bg_color : torch.Tensor, scaling_modifier = 1.0, override_color = None): + """ + Render the scene. + + Background tensor (bg_color) must be on GPU! + """ + # lazy import + if 'GaussianRasterizer' not in globals(): + from diff_gaussian_rasterization import GaussianRasterizer, GaussianRasterizationSettings + + # Create zero tensor. We will use it to make pytorch return gradients of the 2D (screen-space) means + screenspace_points = torch.zeros_like(pc.get_xyz, dtype=pc.get_xyz.dtype, requires_grad=True, device="cuda") + 0 + try: + screenspace_points.retain_grad() + except: + pass + # Set up rasterization configuration + tanfovx = math.tan(viewpoint_camera.FoVx * 0.5) + tanfovy = math.tan(viewpoint_camera.FoVy * 0.5) + + kernel_size = pipe.kernel_size + subpixel_offset = torch.zeros((int(viewpoint_camera.image_height), int(viewpoint_camera.image_width), 2), dtype=torch.float32, device="cuda") + + raster_settings = GaussianRasterizationSettings( + image_height=int(viewpoint_camera.image_height), + image_width=int(viewpoint_camera.image_width), + tanfovx=tanfovx, + tanfovy=tanfovy, + kernel_size=kernel_size, + subpixel_offset=subpixel_offset, + bg=bg_color, + scale_modifier=scaling_modifier, + viewmatrix=viewpoint_camera.world_view_transform, + projmatrix=viewpoint_camera.full_proj_transform, + sh_degree=pc.active_sh_degree, + campos=viewpoint_camera.camera_center, + prefiltered=False, + debug=pipe.debug + ) + + rasterizer = GaussianRasterizer(raster_settings=raster_settings) + + means3D = pc.get_xyz + means2D = screenspace_points + opacity = pc.get_opacity + + # If precomputed 3d covariance is provided, use it. If not, then it will be computed from + # scaling / rotation by the rasterizer. + scales = None + rotations = None + cov3D_precomp = None + if pipe.compute_cov3D_python: + cov3D_precomp = pc.get_covariance(scaling_modifier) + else: + scales = pc.get_scaling + rotations = pc.get_rotation + + # If precomputed colors are provided, use them. Otherwise, if it is desired to precompute colors + # from SHs in Python, do it. If not, then SH -> RGB conversion will be done by rasterizer. + shs = None + colors_precomp = None + if override_color is None: + if pipe.convert_SHs_python: + shs_view = pc.get_features.transpose(1, 2).view(-1, 3, (pc.max_sh_degree+1)**2) + dir_pp = (pc.get_xyz - viewpoint_camera.camera_center.repeat(pc.get_features.shape[0], 1)) + dir_pp_normalized = dir_pp/dir_pp.norm(dim=1, keepdim=True) + sh2rgb = eval_sh(pc.active_sh_degree, shs_view, dir_pp_normalized) + colors_precomp = torch.clamp_min(sh2rgb + 0.5, 0.0) + else: + shs = pc.get_features + else: + colors_precomp = override_color + + # Rasterize visible Gaussians to image, obtain their radii (on screen). + rendered_image, radii = rasterizer( + means3D = means3D, + means2D = means2D, + shs = shs, + colors_precomp = colors_precomp, + opacities = opacity, + scales = scales, + rotations = rotations, + cov3D_precomp = cov3D_precomp + ) + + # Those Gaussians that were frustum culled or had a radius of 0 were not visible. + # They will be excluded from value updates used in the splitting criteria. + return edict({"render": rendered_image, + "viewspace_points": screenspace_points, + "visibility_filter" : radii > 0, + "radii": radii}) + + +class GaussianRenderer: + """ + Renderer for the Voxel representation. + + Args: + rendering_options (dict): Rendering options. + """ + + def __init__(self, rendering_options={}) -> None: + self.pipe = edict({ + "kernel_size": 0.1, + "convert_SHs_python": False, + "compute_cov3D_python": False, + "scale_modifier": 1.0, + "debug": False + }) + self.rendering_options = edict({ + "resolution": None, + "near": None, + "far": None, + "ssaa": 1, + "bg_color": 'random', + }) + self.rendering_options.update(rendering_options) + self.bg_color = None + + def render( + self, + gausssian: Gaussian, + extrinsics: torch.Tensor, + intrinsics: torch.Tensor, + colors_overwrite: torch.Tensor = None + ) -> edict: + """ + Render the gausssian. + + Args: + gaussian : gaussianmodule + extrinsics (torch.Tensor): (4, 4) camera extrinsics + intrinsics (torch.Tensor): (3, 3) camera intrinsics + colors_overwrite (torch.Tensor): (N, 3) override color + + Returns: + edict containing: + color (torch.Tensor): (3, H, W) rendered color image + """ + resolution = self.rendering_options["resolution"] + near = self.rendering_options["near"] + far = self.rendering_options["far"] + ssaa = self.rendering_options["ssaa"] + + if self.rendering_options["bg_color"] == 'random': + self.bg_color = torch.zeros(3, dtype=torch.float32, device="cuda") + if np.random.rand() < 0.5: + self.bg_color += 1 + else: + self.bg_color = torch.tensor(self.rendering_options["bg_color"], dtype=torch.float32, device="cuda") + + view = extrinsics + perspective = intrinsics_to_projection(intrinsics, near, far) + camera = torch.inverse(view)[:3, 3] + focalx = intrinsics[0, 0] + focaly = intrinsics[1, 1] + fovx = 2 * torch.atan(0.5 / focalx) + fovy = 2 * torch.atan(0.5 / focaly) + + camera_dict = edict({ + "image_height": resolution * ssaa, + "image_width": resolution * ssaa, + "FoVx": fovx, + "FoVy": fovy, + "znear": near, + "zfar": far, + "world_view_transform": view.T.contiguous(), + "projection_matrix": perspective.T.contiguous(), + "full_proj_transform": (perspective @ view).T.contiguous(), + "camera_center": camera + }) + + # Render + render_ret = render(camera_dict, gausssian, self.pipe, self.bg_color, override_color=colors_overwrite, scaling_modifier=self.pipe.scale_modifier) + + if ssaa > 1: + render_ret.render = F.interpolate(render_ret.render[None], size=(resolution, resolution), mode='bilinear', align_corners=False, antialias=True).squeeze() + + ret = edict({ + 'color': render_ret['render'] + }) + return ret diff --git a/thirdparty/TRELLIS/trellis/renderers/mesh_renderer.py b/thirdparty/TRELLIS/trellis/renderers/mesh_renderer.py new file mode 100644 index 0000000000000000000000000000000000000000..b504fa4d140c68ef3c611669ea075000d9723a04 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/renderers/mesh_renderer.py @@ -0,0 +1,133 @@ +import torch +import nvdiffrast.torch as dr +from easydict import EasyDict as edict +from ..representations.mesh import MeshExtractResult +import torch.nn.functional as F + + +def intrinsics_to_projection( + intrinsics: torch.Tensor, + near: float, + far: float, + ) -> torch.Tensor: + """ + OpenCV intrinsics to OpenGL perspective matrix + + Args: + intrinsics (torch.Tensor): [3, 3] OpenCV intrinsics matrix + near (float): near plane to clip + far (float): far plane to clip + Returns: + (torch.Tensor): [4, 4] OpenGL perspective matrix + """ + fx, fy = intrinsics[0, 0], intrinsics[1, 1] + cx, cy = intrinsics[0, 2], intrinsics[1, 2] + ret = torch.zeros((4, 4), dtype=intrinsics.dtype, device=intrinsics.device) + ret[0, 0] = 2 * fx + ret[1, 1] = 2 * fy + ret[0, 2] = 2 * cx - 1 + ret[1, 2] = - 2 * cy + 1 + ret[2, 2] = far / (far - near) + ret[2, 3] = near * far / (near - far) + ret[3, 2] = 1. + return ret + + +class MeshRenderer: + """ + Renderer for the Mesh representation. + + Args: + rendering_options (dict): Rendering options. + glctx (nvdiffrast.torch.RasterizeGLContext): RasterizeGLContext object for CUDA/OpenGL interop. + """ + def __init__(self, rendering_options={}, device='cuda'): + self.rendering_options = edict({ + "resolution": None, + "near": None, + "far": None, + "ssaa": 1 + }) + self.rendering_options.update(rendering_options) + self.glctx = dr.RasterizeCudaContext(device=device) + self.device=device + + def render( + self, + mesh : MeshExtractResult, + extrinsics: torch.Tensor, + intrinsics: torch.Tensor, + return_types = ["mask", "normal", "depth"] + ) -> edict: + """ + Render the mesh. + + Args: + mesh : meshmodel + extrinsics (torch.Tensor): (4, 4) camera extrinsics + intrinsics (torch.Tensor): (3, 3) camera intrinsics + return_types (list): list of return types, can be "mask", "depth", "normal_map", "normal", "color" + + Returns: + edict based on return_types containing: + color (torch.Tensor): [3, H, W] rendered color image + depth (torch.Tensor): [H, W] rendered depth image + normal (torch.Tensor): [3, H, W] rendered normal image + normal_map (torch.Tensor): [3, H, W] rendered normal map image + mask (torch.Tensor): [H, W] rendered mask image + """ + resolution = self.rendering_options["resolution"] + near = self.rendering_options["near"] + far = self.rendering_options["far"] + ssaa = self.rendering_options["ssaa"] + + if mesh.vertices.shape[0] == 0 or mesh.faces.shape[0] == 0: + default_img = torch.zeros((1, resolution, resolution, 3), dtype=torch.float32, device=self.device) + ret_dict = {k : default_img if k in ['normal', 'normal_map', 'color'] else default_img[..., :1] for k in return_types} + return ret_dict + + perspective = intrinsics_to_projection(intrinsics, near, far) + + RT = extrinsics.unsqueeze(0) + full_proj = (perspective @ extrinsics).unsqueeze(0) + + vertices = mesh.vertices.unsqueeze(0) + + vertices_homo = torch.cat([vertices, torch.ones_like(vertices[..., :1])], dim=-1) + vertices_camera = torch.bmm(vertices_homo, RT.transpose(-1, -2)) + vertices_clip = torch.bmm(vertices_homo, full_proj.transpose(-1, -2)) + faces_int = mesh.faces.int() + rast, _ = dr.rasterize( + self.glctx, vertices_clip, faces_int, (resolution * ssaa, resolution * ssaa)) + + out_dict = edict() + for type in return_types: + img = None + if type == "mask" : + img = dr.antialias((rast[..., -1:] > 0).float(), rast, vertices_clip, faces_int) + elif type == "depth": + img = dr.interpolate(vertices_camera[..., 2:3].contiguous(), rast, faces_int)[0] + img = dr.antialias(img, rast, vertices_clip, faces_int) + elif type == "normal" : + img = dr.interpolate( + mesh.face_normal.reshape(1, -1, 3), rast, + torch.arange(mesh.faces.shape[0] * 3, device=self.device, dtype=torch.int).reshape(-1, 3) + )[0] + img = dr.antialias(img, rast, vertices_clip, faces_int) + # normalize norm pictures + img = (img + 1) / 2 + elif type == "normal_map" : + img = dr.interpolate(mesh.vertex_attrs[:, 3:].contiguous(), rast, faces_int)[0] + img = dr.antialias(img, rast, vertices_clip, faces_int) + elif type == "color" : + img = dr.interpolate(mesh.vertex_attrs[:, :3].contiguous(), rast, faces_int)[0] + img = dr.antialias(img, rast, vertices_clip, faces_int) + + if ssaa > 1: + img = F.interpolate(img.permute(0, 3, 1, 2), (resolution, resolution), mode='bilinear', align_corners=False, antialias=True) + img = img.squeeze() + else: + img = img.permute(0, 3, 1, 2).squeeze() + out_dict[type] = img + + return out_dict diff --git a/thirdparty/TRELLIS/trellis/renderers/octree_renderer.py b/thirdparty/TRELLIS/trellis/renderers/octree_renderer.py new file mode 100755 index 0000000000000000000000000000000000000000..136069cdb0645b5759d5d17f7815612a1dfc7bea --- /dev/null +++ b/thirdparty/TRELLIS/trellis/renderers/octree_renderer.py @@ -0,0 +1,300 @@ +import numpy as np +import torch +import torch.nn.functional as F +import math +import cv2 +from scipy.stats import qmc +from easydict import EasyDict as edict +from ..representations.octree import DfsOctree + + +def intrinsics_to_projection( + intrinsics: torch.Tensor, + near: float, + far: float, + ) -> torch.Tensor: + """ + OpenCV intrinsics to OpenGL perspective matrix + + Args: + intrinsics (torch.Tensor): [3, 3] OpenCV intrinsics matrix + near (float): near plane to clip + far (float): far plane to clip + Returns: + (torch.Tensor): [4, 4] OpenGL perspective matrix + """ + fx, fy = intrinsics[0, 0], intrinsics[1, 1] + cx, cy = intrinsics[0, 2], intrinsics[1, 2] + ret = torch.zeros((4, 4), dtype=intrinsics.dtype, device=intrinsics.device) + ret[0, 0] = 2 * fx + ret[1, 1] = 2 * fy + ret[0, 2] = 2 * cx - 1 + ret[1, 2] = - 2 * cy + 1 + ret[2, 2] = far / (far - near) + ret[2, 3] = near * far / (near - far) + ret[3, 2] = 1. + return ret + + +def render(viewpoint_camera, octree : DfsOctree, pipe, bg_color : torch.Tensor, scaling_modifier = 1.0, used_rank = None, colors_overwrite = None, aux=None, halton_sampler=None): + """ + Render the scene. + + Background tensor (bg_color) must be on GPU! + """ + # lazy import + if 'OctreeTrivecRasterizer' not in globals(): + from diffoctreerast import OctreeVoxelRasterizer, OctreeGaussianRasterizer, OctreeTrivecRasterizer, OctreeDecoupolyRasterizer + + # Set up rasterization configuration + tanfovx = math.tan(viewpoint_camera.FoVx * 0.5) + tanfovy = math.tan(viewpoint_camera.FoVy * 0.5) + + raster_settings = edict( + image_height=int(viewpoint_camera.image_height), + image_width=int(viewpoint_camera.image_width), + tanfovx=tanfovx, + tanfovy=tanfovy, + bg=bg_color, + scale_modifier=scaling_modifier, + viewmatrix=viewpoint_camera.world_view_transform, + projmatrix=viewpoint_camera.full_proj_transform, + sh_degree=octree.active_sh_degree, + campos=viewpoint_camera.camera_center, + with_distloss=pipe.with_distloss, + jitter=pipe.jitter, + debug=pipe.debug, + ) + + positions = octree.get_xyz + if octree.primitive == "voxel": + densities = octree.get_density + elif octree.primitive == "gaussian": + opacities = octree.get_opacity + elif octree.primitive == "trivec": + trivecs = octree.get_trivec + densities = octree.get_density + raster_settings.density_shift = octree.density_shift + elif octree.primitive == "decoupoly": + decoupolys_V, decoupolys_g = octree.get_decoupoly + densities = octree.get_density + raster_settings.density_shift = octree.density_shift + else: + raise ValueError(f"Unknown primitive {octree.primitive}") + depths = octree.get_depth + + # If precomputed colors are provided, use them. Otherwise, if it is desired to precompute colors + # from SHs in Python, do it. If not, then SH -> RGB conversion will be done by rasterizer. + colors_precomp = None + shs = octree.get_features + if octree.primitive in ["voxel", "gaussian"] and colors_overwrite is not None: + colors_precomp = colors_overwrite + shs = None + + ret = edict() + + if octree.primitive == "voxel": + renderer = OctreeVoxelRasterizer(raster_settings=raster_settings) + rgb, depth, alpha, distloss = renderer( + positions = positions, + densities = densities, + shs = shs, + colors_precomp = colors_precomp, + depths = depths, + aabb = octree.aabb, + aux = aux, + ) + ret['rgb'] = rgb + ret['depth'] = depth + ret['alpha'] = alpha + ret['distloss'] = distloss + elif octree.primitive == "gaussian": + renderer = OctreeGaussianRasterizer(raster_settings=raster_settings) + rgb, depth, alpha = renderer( + positions = positions, + opacities = opacities, + shs = shs, + colors_precomp = colors_precomp, + depths = depths, + aabb = octree.aabb, + aux = aux, + ) + ret['rgb'] = rgb + ret['depth'] = depth + ret['alpha'] = alpha + elif octree.primitive == "trivec": + raster_settings.used_rank = used_rank if used_rank is not None else trivecs.shape[1] + renderer = OctreeTrivecRasterizer(raster_settings=raster_settings) + rgb, depth, alpha, percent_depth = renderer( + positions = positions, + trivecs = trivecs, + densities = densities, + shs = shs, + colors_precomp = colors_precomp, + colors_overwrite = colors_overwrite, + depths = depths, + aabb = octree.aabb, + aux = aux, + halton_sampler = halton_sampler, + ) + ret['percent_depth'] = percent_depth + ret['rgb'] = rgb + ret['depth'] = depth + ret['alpha'] = alpha + elif octree.primitive == "decoupoly": + raster_settings.used_rank = used_rank if used_rank is not None else decoupolys_V.shape[1] + renderer = OctreeDecoupolyRasterizer(raster_settings=raster_settings) + rgb, depth, alpha = renderer( + positions = positions, + decoupolys_V = decoupolys_V, + decoupolys_g = decoupolys_g, + densities = densities, + shs = shs, + colors_precomp = colors_precomp, + depths = depths, + aabb = octree.aabb, + aux = aux, + ) + ret['rgb'] = rgb + ret['depth'] = depth + ret['alpha'] = alpha + + return ret + + +class OctreeRenderer: + """ + Renderer for the Voxel representation. + + Args: + rendering_options (dict): Rendering options. + """ + + def __init__(self, rendering_options={}) -> None: + try: + import diffoctreerast + except ImportError: + print("\033[93m[WARNING] diffoctreerast is not installed. The renderer will be disabled.\033[0m") + self.unsupported = True + else: + self.unsupported = False + + self.pipe = edict({ + "with_distloss": False, + "with_aux": False, + "scale_modifier": 1.0, + "used_rank": None, + "jitter": False, + "debug": False, + }) + self.rendering_options = edict({ + "resolution": None, + "near": None, + "far": None, + "ssaa": 1, + "bg_color": 'random', + }) + self.halton_sampler = qmc.Halton(2, scramble=False) + self.rendering_options.update(rendering_options) + self.bg_color = None + + def render( + self, + octree: DfsOctree, + extrinsics: torch.Tensor, + intrinsics: torch.Tensor, + colors_overwrite: torch.Tensor = None, + ) -> edict: + """ + Render the octree. + + Args: + octree (Octree): octree + extrinsics (torch.Tensor): (4, 4) camera extrinsics + intrinsics (torch.Tensor): (3, 3) camera intrinsics + colors_overwrite (torch.Tensor): (N, 3) override color + + Returns: + edict containing: + color (torch.Tensor): (3, H, W) rendered color + depth (torch.Tensor): (H, W) rendered depth + alpha (torch.Tensor): (H, W) rendered alpha + distloss (Optional[torch.Tensor]): (H, W) rendered distance loss + percent_depth (Optional[torch.Tensor]): (H, W) rendered percent depth + aux (Optional[edict]): auxiliary tensors + """ + resolution = self.rendering_options["resolution"] + near = self.rendering_options["near"] + far = self.rendering_options["far"] + ssaa = self.rendering_options["ssaa"] + + if self.unsupported: + image = np.zeros((512, 512, 3), dtype=np.uint8) + text_bbox = cv2.getTextSize("Unsupported", cv2.FONT_HERSHEY_SIMPLEX, 2, 3)[0] + origin = (512 - text_bbox[0]) // 2, (512 - text_bbox[1]) // 2 + image = cv2.putText(image, "Unsupported", origin, cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 3, cv2.LINE_AA) + return { + 'color': torch.tensor(image, dtype=torch.float32).permute(2, 0, 1) / 255, + } + + if self.rendering_options["bg_color"] == 'random': + self.bg_color = torch.zeros(3, dtype=torch.float32, device="cuda") + if np.random.rand() < 0.5: + self.bg_color += 1 + else: + self.bg_color = torch.tensor(self.rendering_options["bg_color"], dtype=torch.float32, device="cuda") + + if self.pipe["with_aux"]: + aux = { + 'grad_color2': torch.zeros((octree.num_leaf_nodes, 3), dtype=torch.float32, requires_grad=True, device="cuda") + 0, + 'contributions': torch.zeros((octree.num_leaf_nodes, 1), dtype=torch.float32, requires_grad=True, device="cuda") + 0, + } + for k in aux.keys(): + aux[k].requires_grad_() + aux[k].retain_grad() + else: + aux = None + + view = extrinsics + perspective = intrinsics_to_projection(intrinsics, near, far) + camera = torch.inverse(view)[:3, 3] + focalx = intrinsics[0, 0] + focaly = intrinsics[1, 1] + fovx = 2 * torch.atan(0.5 / focalx) + fovy = 2 * torch.atan(0.5 / focaly) + + camera_dict = edict({ + "image_height": resolution * ssaa, + "image_width": resolution * ssaa, + "FoVx": fovx, + "FoVy": fovy, + "znear": near, + "zfar": far, + "world_view_transform": view.T.contiguous(), + "projection_matrix": perspective.T.contiguous(), + "full_proj_transform": (perspective @ view).T.contiguous(), + "camera_center": camera + }) + + # Render + render_ret = render(camera_dict, octree, self.pipe, self.bg_color, aux=aux, colors_overwrite=colors_overwrite, scaling_modifier=self.pipe.scale_modifier, used_rank=self.pipe.used_rank, halton_sampler=self.halton_sampler) + + if ssaa > 1: + render_ret.rgb = F.interpolate(render_ret.rgb[None], size=(resolution, resolution), mode='bilinear', align_corners=False, antialias=True).squeeze() + render_ret.depth = F.interpolate(render_ret.depth[None, None], size=(resolution, resolution), mode='bilinear', align_corners=False, antialias=True).squeeze() + render_ret.alpha = F.interpolate(render_ret.alpha[None, None], size=(resolution, resolution), mode='bilinear', align_corners=False, antialias=True).squeeze() + if hasattr(render_ret, 'percent_depth'): + render_ret.percent_depth = F.interpolate(render_ret.percent_depth[None, None], size=(resolution, resolution), mode='bilinear', align_corners=False, antialias=True).squeeze() + + ret = edict({ + 'color': render_ret.rgb, + 'depth': render_ret.depth, + 'alpha': render_ret.alpha, + }) + if self.pipe["with_distloss"] and 'distloss' in render_ret: + ret['distloss'] = render_ret.distloss + if self.pipe["with_aux"]: + ret['aux'] = aux + if hasattr(render_ret, 'percent_depth'): + ret['percent_depth'] = render_ret.percent_depth + return ret diff --git a/thirdparty/TRELLIS/trellis/renderers/sh_utils.py b/thirdparty/TRELLIS/trellis/renderers/sh_utils.py new file mode 100755 index 0000000000000000000000000000000000000000..bbca7d192aa3a7edf8c5b2d24dee535eac765785 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/renderers/sh_utils.py @@ -0,0 +1,118 @@ +# Copyright 2021 The PlenOctree Authors. +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import torch + +C0 = 0.28209479177387814 +C1 = 0.4886025119029199 +C2 = [ + 1.0925484305920792, + -1.0925484305920792, + 0.31539156525252005, + -1.0925484305920792, + 0.5462742152960396 +] +C3 = [ + -0.5900435899266435, + 2.890611442640554, + -0.4570457994644658, + 0.3731763325901154, + -0.4570457994644658, + 1.445305721320277, + -0.5900435899266435 +] +C4 = [ + 2.5033429417967046, + -1.7701307697799304, + 0.9461746957575601, + -0.6690465435572892, + 0.10578554691520431, + -0.6690465435572892, + 0.47308734787878004, + -1.7701307697799304, + 0.6258357354491761, +] + + +def eval_sh(deg, sh, dirs): + """ + Evaluate spherical harmonics at unit directions + using hardcoded SH polynomials. + Works with torch/np/jnp. + ... Can be 0 or more batch dimensions. + Args: + deg: int SH deg. Currently, 0-3 supported + sh: jnp.ndarray SH coeffs [..., C, (deg + 1) ** 2] + dirs: jnp.ndarray unit directions [..., 3] + Returns: + [..., C] + """ + assert deg <= 4 and deg >= 0 + coeff = (deg + 1) ** 2 + assert sh.shape[-1] >= coeff + + result = C0 * sh[..., 0] + if deg > 0: + x, y, z = dirs[..., 0:1], dirs[..., 1:2], dirs[..., 2:3] + result = (result - + C1 * y * sh[..., 1] + + C1 * z * sh[..., 2] - + C1 * x * sh[..., 3]) + + if deg > 1: + xx, yy, zz = x * x, y * y, z * z + xy, yz, xz = x * y, y * z, x * z + result = (result + + C2[0] * xy * sh[..., 4] + + C2[1] * yz * sh[..., 5] + + C2[2] * (2.0 * zz - xx - yy) * sh[..., 6] + + C2[3] * xz * sh[..., 7] + + C2[4] * (xx - yy) * sh[..., 8]) + + if deg > 2: + result = (result + + C3[0] * y * (3 * xx - yy) * sh[..., 9] + + C3[1] * xy * z * sh[..., 10] + + C3[2] * y * (4 * zz - xx - yy)* sh[..., 11] + + C3[3] * z * (2 * zz - 3 * xx - 3 * yy) * sh[..., 12] + + C3[4] * x * (4 * zz - xx - yy) * sh[..., 13] + + C3[5] * z * (xx - yy) * sh[..., 14] + + C3[6] * x * (xx - 3 * yy) * sh[..., 15]) + + if deg > 3: + result = (result + C4[0] * xy * (xx - yy) * sh[..., 16] + + C4[1] * yz * (3 * xx - yy) * sh[..., 17] + + C4[2] * xy * (7 * zz - 1) * sh[..., 18] + + C4[3] * yz * (7 * zz - 3) * sh[..., 19] + + C4[4] * (zz * (35 * zz - 30) + 3) * sh[..., 20] + + C4[5] * xz * (7 * zz - 3) * sh[..., 21] + + C4[6] * (xx - yy) * (7 * zz - 1) * sh[..., 22] + + C4[7] * xz * (xx - 3 * yy) * sh[..., 23] + + C4[8] * (xx * (xx - 3 * yy) - yy * (3 * xx - yy)) * sh[..., 24]) + return result + +def RGB2SH(rgb): + return (rgb - 0.5) / C0 + +def SH2RGB(sh): + return sh * C0 + 0.5 \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/representations/__init__.py b/thirdparty/TRELLIS/trellis/representations/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..549ffdb97e87181552e9b3e086766f873e4bfb5e --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/__init__.py @@ -0,0 +1,4 @@ +from .radiance_field import Strivec +from .octree import DfsOctree as Octree +from .gaussian import Gaussian +from .mesh import MeshExtractResult diff --git a/thirdparty/TRELLIS/trellis/representations/gaussian/__init__.py b/thirdparty/TRELLIS/trellis/representations/gaussian/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e3de6e180bd732836af876d748255595be2d4d74 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/gaussian/__init__.py @@ -0,0 +1 @@ +from .gaussian_model import Gaussian \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/representations/gaussian/gaussian_model.py b/thirdparty/TRELLIS/trellis/representations/gaussian/gaussian_model.py new file mode 100755 index 0000000000000000000000000000000000000000..54ba16f1550e8edb1728605202cc31b6dd805d90 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/gaussian/gaussian_model.py @@ -0,0 +1,209 @@ +import torch +import numpy as np +from plyfile import PlyData, PlyElement +from .general_utils import inverse_sigmoid, strip_symmetric, build_scaling_rotation +import utils3d + + +class Gaussian: + def __init__( + self, + aabb : list, + sh_degree : int = 0, + mininum_kernel_size : float = 0.0, + scaling_bias : float = 0.01, + opacity_bias : float = 0.1, + scaling_activation : str = "exp", + device='cuda' + ): + self.init_params = { + 'aabb': aabb, + 'sh_degree': sh_degree, + 'mininum_kernel_size': mininum_kernel_size, + 'scaling_bias': scaling_bias, + 'opacity_bias': opacity_bias, + 'scaling_activation': scaling_activation, + } + + self.sh_degree = sh_degree + self.active_sh_degree = sh_degree + self.mininum_kernel_size = mininum_kernel_size + self.scaling_bias = scaling_bias + self.opacity_bias = opacity_bias + self.scaling_activation_type = scaling_activation + self.device = device + self.aabb = torch.tensor(aabb, dtype=torch.float32, device=device) + self.setup_functions() + + self._xyz = None + self._features_dc = None + self._features_rest = None + self._scaling = None + self._rotation = None + self._opacity = None + + def setup_functions(self): + def build_covariance_from_scaling_rotation(scaling, scaling_modifier, rotation): + L = build_scaling_rotation(scaling_modifier * scaling, rotation) + actual_covariance = L @ L.transpose(1, 2) + symm = strip_symmetric(actual_covariance) + return symm + + if self.scaling_activation_type == "exp": + self.scaling_activation = torch.exp + self.inverse_scaling_activation = torch.log + elif self.scaling_activation_type == "softplus": + self.scaling_activation = torch.nn.functional.softplus + self.inverse_scaling_activation = lambda x: x + torch.log(-torch.expm1(-x)) + + self.covariance_activation = build_covariance_from_scaling_rotation + + self.opacity_activation = torch.sigmoid + self.inverse_opacity_activation = inverse_sigmoid + + self.rotation_activation = torch.nn.functional.normalize + + self.scale_bias = self.inverse_scaling_activation(torch.tensor(self.scaling_bias)).cuda() + self.rots_bias = torch.zeros((4)).cuda() + self.rots_bias[0] = 1 + self.opacity_bias = self.inverse_opacity_activation(torch.tensor(self.opacity_bias)).cuda() + + @property + def get_scaling(self): + scales = self.scaling_activation(self._scaling + self.scale_bias) + scales = torch.square(scales) + self.mininum_kernel_size ** 2 + scales = torch.sqrt(scales) + return scales + + @property + def get_rotation(self): + return self.rotation_activation(self._rotation + self.rots_bias[None, :]) + + @property + def get_xyz(self): + return self._xyz * self.aabb[None, 3:] + self.aabb[None, :3] + + @property + def get_features(self): + return torch.cat((self._features_dc, self._features_rest), dim=2) if self._features_rest is not None else self._features_dc + + @property + def get_opacity(self): + return self.opacity_activation(self._opacity + self.opacity_bias) + + def get_covariance(self, scaling_modifier = 1): + return self.covariance_activation(self.get_scaling, scaling_modifier, self._rotation + self.rots_bias[None, :]) + + def from_scaling(self, scales): + scales = torch.sqrt(torch.square(scales) - self.mininum_kernel_size ** 2) + self._scaling = self.inverse_scaling_activation(scales) - self.scale_bias + + def from_rotation(self, rots): + self._rotation = rots - self.rots_bias[None, :] + + def from_xyz(self, xyz): + self._xyz = (xyz - self.aabb[None, :3]) / self.aabb[None, 3:] + + def from_features(self, features): + self._features_dc = features + + def from_opacity(self, opacities): + self._opacity = self.inverse_opacity_activation(opacities) - self.opacity_bias + + def construct_list_of_attributes(self): + l = ['x', 'y', 'z', 'nx', 'ny', 'nz'] + # All channels except the 3 DC + for i in range(self._features_dc.shape[1]*self._features_dc.shape[2]): + l.append('f_dc_{}'.format(i)) + l.append('opacity') + for i in range(self._scaling.shape[1]): + l.append('scale_{}'.format(i)) + for i in range(self._rotation.shape[1]): + l.append('rot_{}'.format(i)) + return l + + def save_ply(self, path, transform=[[1, 0, 0], [0, 0, -1], [0, 1, 0]]): + xyz = self.get_xyz.detach().cpu().numpy() + normals = np.zeros_like(xyz) + f_dc = self._features_dc.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu().numpy() + opacities = inverse_sigmoid(self.get_opacity).detach().cpu().numpy() + scale = torch.log(self.get_scaling).detach().cpu().numpy() + rotation = (self._rotation + self.rots_bias[None, :]).detach().cpu().numpy() + + if transform is not None: + transform = np.array(transform) + xyz = np.matmul(xyz, transform.T) + rotation = utils3d.numpy.quaternion_to_matrix(rotation) + rotation = np.matmul(transform, rotation) + rotation = utils3d.numpy.matrix_to_quaternion(rotation) + + dtype_full = [(attribute, 'f4') for attribute in self.construct_list_of_attributes()] + + elements = np.empty(xyz.shape[0], dtype=dtype_full) + attributes = np.concatenate((xyz, normals, f_dc, opacities, scale, rotation), axis=1) + elements[:] = list(map(tuple, attributes)) + el = PlyElement.describe(elements, 'vertex') + PlyData([el]).write(path) + + def load_ply(self, path, transform=[[1, 0, 0], [0, 0, -1], [0, 1, 0]]): + plydata = PlyData.read(path) + + xyz = np.stack((np.asarray(plydata.elements[0]["x"]), + np.asarray(plydata.elements[0]["y"]), + np.asarray(plydata.elements[0]["z"])), axis=1) + opacities = np.asarray(plydata.elements[0]["opacity"])[..., np.newaxis] + + features_dc = np.zeros((xyz.shape[0], 3, 1)) + features_dc[:, 0, 0] = np.asarray(plydata.elements[0]["f_dc_0"]) + features_dc[:, 1, 0] = np.asarray(plydata.elements[0]["f_dc_1"]) + features_dc[:, 2, 0] = np.asarray(plydata.elements[0]["f_dc_2"]) + + if self.sh_degree > 0: + extra_f_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("f_rest_")] + extra_f_names = sorted(extra_f_names, key = lambda x: int(x.split('_')[-1])) + assert len(extra_f_names)==3*(self.sh_degree + 1) ** 2 - 3 + features_extra = np.zeros((xyz.shape[0], len(extra_f_names))) + for idx, attr_name in enumerate(extra_f_names): + features_extra[:, idx] = np.asarray(plydata.elements[0][attr_name]) + # Reshape (P,F*SH_coeffs) to (P, F, SH_coeffs except DC) + features_extra = features_extra.reshape((features_extra.shape[0], 3, (self.max_sh_degree + 1) ** 2 - 1)) + + scale_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("scale_")] + scale_names = sorted(scale_names, key = lambda x: int(x.split('_')[-1])) + scales = np.zeros((xyz.shape[0], len(scale_names))) + for idx, attr_name in enumerate(scale_names): + scales[:, idx] = np.asarray(plydata.elements[0][attr_name]) + + rot_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("rot")] + rot_names = sorted(rot_names, key = lambda x: int(x.split('_')[-1])) + rots = np.zeros((xyz.shape[0], len(rot_names))) + for idx, attr_name in enumerate(rot_names): + rots[:, idx] = np.asarray(plydata.elements[0][attr_name]) + + if transform is not None: + transform = np.array(transform) + xyz = np.matmul(xyz, transform) + rotation = utils3d.numpy.quaternion_to_matrix(rotation) + rotation = np.matmul(rotation, transform) + rotation = utils3d.numpy.matrix_to_quaternion(rotation) + + # convert to actual gaussian attributes + xyz = torch.tensor(xyz, dtype=torch.float, device=self.device) + features_dc = torch.tensor(features_dc, dtype=torch.float, device=self.device).transpose(1, 2).contiguous() + if self.sh_degree > 0: + features_extra = torch.tensor(features_extra, dtype=torch.float, device=self.device).transpose(1, 2).contiguous() + opacities = torch.sigmoid(torch.tensor(opacities, dtype=torch.float, device=self.device)) + scales = torch.exp(torch.tensor(scales, dtype=torch.float, device=self.device)) + rots = torch.tensor(rots, dtype=torch.float, device=self.device) + + # convert to _hidden attributes + self._xyz = (xyz - self.aabb[None, :3]) / self.aabb[None, 3:] + self._features_dc = features_dc + if self.sh_degree > 0: + self._features_rest = features_extra + else: + self._features_rest = None + self._opacity = self.inverse_opacity_activation(opacities) - self.opacity_bias + self._scaling = self.inverse_scaling_activation(torch.sqrt(torch.square(scales) - self.mininum_kernel_size ** 2)) - self.scale_bias + self._rotation = rots - self.rots_bias[None, :] + \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/representations/gaussian/general_utils.py b/thirdparty/TRELLIS/trellis/representations/gaussian/general_utils.py new file mode 100755 index 0000000000000000000000000000000000000000..541c0825229a2d86e84460b765879f86f724a59d --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/gaussian/general_utils.py @@ -0,0 +1,133 @@ +# +# Copyright (C) 2023, Inria +# GRAPHDECO research group, https://team.inria.fr/graphdeco +# All rights reserved. +# +# This software is free for non-commercial, research and evaluation use +# under the terms of the LICENSE.md file. +# +# For inquiries contact george.drettakis@inria.fr +# + +import torch +import sys +from datetime import datetime +import numpy as np +import random + +def inverse_sigmoid(x): + return torch.log(x/(1-x)) + +def PILtoTorch(pil_image, resolution): + resized_image_PIL = pil_image.resize(resolution) + resized_image = torch.from_numpy(np.array(resized_image_PIL)) / 255.0 + if len(resized_image.shape) == 3: + return resized_image.permute(2, 0, 1) + else: + return resized_image.unsqueeze(dim=-1).permute(2, 0, 1) + +def get_expon_lr_func( + lr_init, lr_final, lr_delay_steps=0, lr_delay_mult=1.0, max_steps=1000000 +): + """ + Copied from Plenoxels + + Continuous learning rate decay function. Adapted from JaxNeRF + The returned rate is lr_init when step=0 and lr_final when step=max_steps, and + is log-linearly interpolated elsewhere (equivalent to exponential decay). + If lr_delay_steps>0 then the learning rate will be scaled by some smooth + function of lr_delay_mult, such that the initial learning rate is + lr_init*lr_delay_mult at the beginning of optimization but will be eased back + to the normal learning rate when steps>lr_delay_steps. + :param conf: config subtree 'lr' or similar + :param max_steps: int, the number of steps during optimization. + :return HoF which takes step as input + """ + + def helper(step): + if step < 0 or (lr_init == 0.0 and lr_final == 0.0): + # Disable this parameter + return 0.0 + if lr_delay_steps > 0: + # A kind of reverse cosine decay. + delay_rate = lr_delay_mult + (1 - lr_delay_mult) * np.sin( + 0.5 * np.pi * np.clip(step / lr_delay_steps, 0, 1) + ) + else: + delay_rate = 1.0 + t = np.clip(step / max_steps, 0, 1) + log_lerp = np.exp(np.log(lr_init) * (1 - t) + np.log(lr_final) * t) + return delay_rate * log_lerp + + return helper + +def strip_lowerdiag(L): + uncertainty = torch.zeros((L.shape[0], 6), dtype=torch.float, device="cuda") + + uncertainty[:, 0] = L[:, 0, 0] + uncertainty[:, 1] = L[:, 0, 1] + uncertainty[:, 2] = L[:, 0, 2] + uncertainty[:, 3] = L[:, 1, 1] + uncertainty[:, 4] = L[:, 1, 2] + uncertainty[:, 5] = L[:, 2, 2] + return uncertainty + +def strip_symmetric(sym): + return strip_lowerdiag(sym) + +def build_rotation(r): + norm = torch.sqrt(r[:,0]*r[:,0] + r[:,1]*r[:,1] + r[:,2]*r[:,2] + r[:,3]*r[:,3]) + + q = r / norm[:, None] + + R = torch.zeros((q.size(0), 3, 3), device='cuda') + + r = q[:, 0] + x = q[:, 1] + y = q[:, 2] + z = q[:, 3] + + R[:, 0, 0] = 1 - 2 * (y*y + z*z) + R[:, 0, 1] = 2 * (x*y - r*z) + R[:, 0, 2] = 2 * (x*z + r*y) + R[:, 1, 0] = 2 * (x*y + r*z) + R[:, 1, 1] = 1 - 2 * (x*x + z*z) + R[:, 1, 2] = 2 * (y*z - r*x) + R[:, 2, 0] = 2 * (x*z - r*y) + R[:, 2, 1] = 2 * (y*z + r*x) + R[:, 2, 2] = 1 - 2 * (x*x + y*y) + return R + +def build_scaling_rotation(s, r): + L = torch.zeros((s.shape[0], 3, 3), dtype=torch.float, device="cuda") + R = build_rotation(r) + + L[:,0,0] = s[:,0] + L[:,1,1] = s[:,1] + L[:,2,2] = s[:,2] + + L = R @ L + return L + +def safe_state(silent): + old_f = sys.stdout + class F: + def __init__(self, silent): + self.silent = silent + + def write(self, x): + if not self.silent: + if x.endswith("\n"): + old_f.write(x.replace("\n", " [{}]\n".format(str(datetime.now().strftime("%d/%m %H:%M:%S"))))) + else: + old_f.write(x) + + def flush(self): + old_f.flush() + + sys.stdout = F(silent) + + random.seed(0) + np.random.seed(0) + torch.manual_seed(0) + torch.cuda.set_device(torch.device("cuda:0")) diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/__init__.py b/thirdparty/TRELLIS/trellis/representations/mesh/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..38cf35c0853d11cf09bdc228a87ee9d0b2f34b62 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/__init__.py @@ -0,0 +1 @@ +from .cube2mesh import SparseFeatures2Mesh, MeshExtractResult diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/cube2mesh.py b/thirdparty/TRELLIS/trellis/representations/mesh/cube2mesh.py new file mode 100644 index 0000000000000000000000000000000000000000..44e8776fafbc21d787e2ba855e4c99bd191a0762 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/cube2mesh.py @@ -0,0 +1,143 @@ +import torch +from ...modules.sparse import SparseTensor +from easydict import EasyDict as edict +from .utils_cube import * +from .flexicubes.flexicubes import FlexiCubes + + +class MeshExtractResult: + def __init__(self, + vertices, + faces, + vertex_attrs=None, + res=64 + ): + self.vertices = vertices + self.faces = faces.long() + self.vertex_attrs = vertex_attrs + self.face_normal = self.comput_face_normals(vertices, faces) + self.res = res + self.success = (vertices.shape[0] != 0 and faces.shape[0] != 0) + + # training only + self.tsdf_v = None + self.tsdf_s = None + self.reg_loss = None + + def comput_face_normals(self, verts, faces): + i0 = faces[..., 0].long() + i1 = faces[..., 1].long() + i2 = faces[..., 2].long() + + v0 = verts[i0, :] + v1 = verts[i1, :] + v2 = verts[i2, :] + face_normals = torch.cross(v1 - v0, v2 - v0, dim=-1) + face_normals = torch.nn.functional.normalize(face_normals, dim=1) + # print(face_normals.min(), face_normals.max(), face_normals.shape) + return face_normals[:, None, :].repeat(1, 3, 1) + + def comput_v_normals(self, verts, faces): + i0 = faces[..., 0].long() + i1 = faces[..., 1].long() + i2 = faces[..., 2].long() + + v0 = verts[i0, :] + v1 = verts[i1, :] + v2 = verts[i2, :] + face_normals = torch.cross(v1 - v0, v2 - v0, dim=-1) + v_normals = torch.zeros_like(verts) + v_normals.scatter_add_(0, i0[..., None].repeat(1, 3), face_normals) + v_normals.scatter_add_(0, i1[..., None].repeat(1, 3), face_normals) + v_normals.scatter_add_(0, i2[..., None].repeat(1, 3), face_normals) + + v_normals = torch.nn.functional.normalize(v_normals, dim=1) + return v_normals + + +class SparseFeatures2Mesh: + def __init__(self, device="cuda", res=64, use_color=True): + ''' + a model to generate a mesh from sparse features structures using flexicube + ''' + super().__init__() + self.device=device + self.res = res + self.mesh_extractor = FlexiCubes(device=device) + self.sdf_bias = -1.0 / res + verts, cube = construct_dense_grid(self.res, self.device) + self.reg_c = cube.to(self.device) + self.reg_v = verts.to(self.device) + self.use_color = use_color + self._calc_layout() + + def _calc_layout(self): + LAYOUTS = { + 'sdf': {'shape': (8, 1), 'size': 8}, + 'deform': {'shape': (8, 3), 'size': 8 * 3}, + 'weights': {'shape': (21,), 'size': 21} + } + if self.use_color: + ''' + 6 channel color including normal map + ''' + LAYOUTS['color'] = {'shape': (8, 6,), 'size': 8 * 6} + self.layouts = edict(LAYOUTS) + start = 0 + for k, v in self.layouts.items(): + v['range'] = (start, start + v['size']) + start += v['size'] + self.feats_channels = start + + def get_layout(self, feats : torch.Tensor, name : str): + if name not in self.layouts: + return None + return feats[:, self.layouts[name]['range'][0]:self.layouts[name]['range'][1]].reshape(-1, *self.layouts[name]['shape']) + + def __call__(self, cubefeats : SparseTensor, training=False): + """ + Generates a mesh based on the specified sparse voxel structures. + Args: + cube_attrs [Nx21] : Sparse Tensor attrs about cube weights + verts_attrs [Nx10] : [0:1] SDF [1:4] deform [4:7] color [7:10] normal + Returns: + return the success tag and ni you loss, + """ + # add sdf bias to verts_attrs + coords = cubefeats.coords[:, 1:] + feats = cubefeats.feats + + sdf, deform, color, weights = [self.get_layout(feats, name) for name in ['sdf', 'deform', 'color', 'weights']] + sdf += self.sdf_bias + v_attrs = [sdf, deform, color] if self.use_color else [sdf, deform] + v_pos, v_attrs, reg_loss = sparse_cube2verts(coords, torch.cat(v_attrs, dim=-1), training=training) + v_attrs_d = get_dense_attrs(v_pos, v_attrs, res=self.res+1, sdf_init=True) + weights_d = get_dense_attrs(coords, weights, res=self.res, sdf_init=False) + if self.use_color: + sdf_d, deform_d, colors_d = v_attrs_d[..., 0], v_attrs_d[..., 1:4], v_attrs_d[..., 4:] + else: + sdf_d, deform_d = v_attrs_d[..., 0], v_attrs_d[..., 1:4] + colors_d = None + + x_nx3 = get_defomed_verts(self.reg_v, deform_d, self.res) + + vertices, faces, L_dev, colors = self.mesh_extractor( + voxelgrid_vertices=x_nx3, + scalar_field=sdf_d, + cube_idx=self.reg_c, + resolution=self.res, + beta=weights_d[:, :12], + alpha=weights_d[:, 12:20], + gamma_f=weights_d[:, 20], + voxelgrid_colors=colors_d, + training=training) + + mesh = MeshExtractResult(vertices=vertices, faces=faces, vertex_attrs=colors, res=self.res) + if training: + if mesh.success: + reg_loss += L_dev.mean() * 0.5 + reg_loss += (weights[:,:20]).abs().mean() * 0.2 + mesh.reg_loss = reg_loss + mesh.tsdf_v = get_defomed_verts(v_pos, v_attrs[:, 1:4], self.res) + mesh.tsdf_s = v_attrs[:, 0] + return mesh diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/LICENSE.txt b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..40e8f765ee25d88128e7b5cd769389c633ba86bb --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/LICENSE.txt @@ -0,0 +1,90 @@ +Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + + +NVIDIA Source Code License for FlexiCubes + + +======================================================================= + +1. Definitions + +“Licensor” means any person or entity that distributes its Work. + +“Work” means (a) the original work of authorship made available under +this license, which may include software, documentation, or other files, +and (b) any additions to or derivative works thereof that are made +available under this license. + +The terms “reproduce,” “reproduction,” “derivative works,” and +“distribution” have the meaning as provided under U.S. copyright law; +provided, however, that for the purposes of this license, derivative works +shall not include works that remain separable from, or merely link +(or bind by name) to the interfaces of, the Work. + +Works are “made available” under this license by including in or with +the Work either (a) a copyright notice referencing the applicability of +this license to the Work, or (b) a copy of this license. + +2. License Grant + + 2.1 Copyright Grant. Subject to the terms and conditions of this license, + each Licensor grants to you a perpetual, worldwide, non-exclusive, + royalty-free, copyright license to use, reproduce, prepare derivative + works of, publicly display, publicly perform, sublicense and distribute + its Work and any resulting derivative works in any form. + +3. Limitations + + 3.1 Redistribution. You may reproduce or distribute the Work only if + (a) you do so under this license, (b) you include a complete copy of + this license with your distribution, and (c) you retain without + modification any copyright, patent, trademark, or attribution notices + that are present in the Work. + + 3.2 Derivative Works. You may specify that additional or different terms + apply to the use, reproduction, and distribution of your derivative + works of the Work (“Your Terms”) only if (a) Your Terms provide that the + use limitation in Section 3.3 applies to your derivative works, and (b) + you identify the specific derivative works that are subject to Your Terms. + Notwithstanding Your Terms, this license (including the redistribution + requirements in Section 3.1) will continue to apply to the Work itself. + + 3.3 Use Limitation. The Work and any derivative works thereof only may be + used or intended for use non-commercially. Notwithstanding the foregoing, + NVIDIA Corporation and its affiliates may use the Work and any derivative + works commercially. As used herein, “non-commercially” means for research + or evaluation purposes only. + + 3.4 Patent Claims. If you bring or threaten to bring a patent claim against + any Licensor (including any claim, cross-claim or counterclaim in a lawsuit) + to enforce any patents that you allege are infringed by any Work, then your + rights under this license from such Licensor (including the grant in + Section 2.1) will terminate immediately. + + 3.5 Trademarks. This license does not grant any rights to use any Licensor’s + or its affiliates’ names, logos, or trademarks, except as necessary to + reproduce the notices described in this license. + + 3.6 Termination. If you violate any term of this license, then your rights + under this license (including the grant in Section 2.1) will terminate + immediately. + +4. Disclaimer of Warranty. + +THE WORK IS PROVIDED “AS IS” WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, +EITHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OR CONDITIONS OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR NON-INFRINGEMENT. +YOU BEAR THE RISK OF UNDERTAKING ANY ACTIVITIES UNDER THIS LICENSE. + +5. Limitation of Liability. + +EXCEPT AS PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL THEORY, +WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE SHALL ANY +LICENSOR BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT, INDIRECT, SPECIAL, +INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATED TO THIS LICENSE, +THE USE OR INABILITY TO USE THE WORK (INCLUDING BUT NOT LIMITED TO LOSS OF +GOODWILL, BUSINESS INTERRUPTION, LOST PROFITS OR DATA, COMPUTER FAILURE OR +MALFUNCTION, OR ANY OTHER DAMAGES OR LOSSES), EVEN IF THE LICENSOR HAS BEEN +ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +======================================================================= \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/README.md b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/README.md new file mode 100644 index 0000000000000000000000000000000000000000..8f8b460651edef71c9636d62868c239defaa73ce --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/README.md @@ -0,0 +1,110 @@ +## Flexible Isosurface Extraction for Gradient-Based Mesh Optimization (FlexiCubes)
Official PyTorch implementation + +![Teaser image]() + +FlexiCubes is a high-quality isosurface representation specifically designed for gradient-based mesh optimization with respect to geometric, visual, or even physical objectives. For more details, please refer to our [paper](https://arxiv.org/abs/2308.05371) and [project page](https://research.nvidia.com/labs/toronto-ai/flexicubes/). + +## Highlights +* [Getting started](https://github.com/nv-tlabs/FlexiCubes#getting-started) +* [Basic workflow](https://github.com/nv-tlabs/FlexiCubes#example-usage) +* [nvdiffrec: image-based reconstruction example](https://github.com/NVlabs/nvdiffrec#news) +* [GET3D: generative AI example](https://github.com/nv-tlabs/GET3D#employing-flexicubes) +* [Bibtex](https://github.com/nv-tlabs/FlexiCubes#citation) + +## Getting Started + +The core functions of FlexiCubes are now in [Kaolin](https://github.com/NVIDIAGameWorks/kaolin/) starting from v0.15.0. See installation instructions [here](https://kaolin.readthedocs.io/en/latest/notes/installation.html) and API documentations [here](https://kaolin.readthedocs.io/en/latest/modules/kaolin.non_commercial.html#kaolin.non_commercial.FlexiCubes) + +The original code of the paper is still visible in `flexicube.py`. + +## Example Usage + +### Gradient-Based Mesh Optimization +We provide examples demonstrating how to use FlexiCubes for reconstructing unknown meshes through gradient-based optimization. Specifically, starting from randomly initialized SDF, we optimize the shape towards the reference mesh by minimizing their geometric difference, measured by multiview mask and depth losses. This workflow is a simplified version of `nvdiffrec` with code largely borrowed from the [nvdiffrec GitHub](https://github.com/NVlabs/nvdiffrec). We use the same pipeline to conduct the analysis in Section 3 and the main experiments described in Section 5 of our paper. We provide a detailed tutorial in `examples/optimization.ipynb`, along with an optimization script in `examples/optimize.py` which accepts command-line arguments. + + +To run the examples, it is suggested to install the Conda environment as detailed below: +```sh +conda create -n flexicubes python=3.9 +conda activate flexicubes +conda install pytorch==1.12.0 torchvision==0.13.0 torchaudio==0.12.0 cudatoolkit=11.3 -c pytorch +pip install imageio trimesh tqdm matplotlib torch_scatter ninja +pip install git+https://github.com/NVlabs/nvdiffrast/ +pip install kaolin==0.15.0 -f https://nvidia-kaolin.s3.us-east-2.amazonaws.com/torch-1.12.0_cu113.html +``` + +Then download the dataset collected by [Myles et al.](https://vcg.isti.cnr.it/Publications/2014/MPZ14/) as follows. We include one shape in 'examples/data/inputmodels/block.obj' if you want to test without downloading the full dataset. + +```sh +cd examples +python download_data.py +``` + +After downloading the data, run shape optimization with the following example command: +```sh +python optimize.py --ref_mesh data/inputmodels/block.obj --out_dir out/block +``` +You can find visualization and output meshes in the `out/block`. Below, we show the initial and final shapes during optimization, with the reference shape on the right. + +block_init + +block_final + + +To further demonstrate the flexibility of our FlexiCubes representation, which can accommodates both reconstruction objectives and regularizers defined on the extracted mesh, you can add a developability regularizer (proposed by [Stein et al.](https://www.cs.cmu.edu/~kmcrane/Projects/DiscreteDevelopable/)) to the previous reconstruction pipeline to encourage fabricability from panels: +```sh +python optimize.py --ref_mesh data/inputmodels/david.obj --out_dir out/david_dev --develop_reg True --iter=1250 +``` + +### Extract mesh from known signed distance field +While not its designated use case, our function can extract a mesh from a known Signed Distance Field (SDF) without optimization. Please refer to the tutorial found in `examples/extraction.ipynb` for details. + +## Tips for using FlexiCubes +### Regularization losses: +We commonly use three regularizers in our mesh optimization pipelines, referenced in lines `L104-L106` in `examples/optimize.py`. The weights of these regularizers should be scaled according to the your application objectives. Initially, it is suggested to employ low weights because strong regularization can hinder convergence. You can incrementally increase the weights if you notice artifacts appearing in the optimized meshes. Specifically: + +* The loss function at `L104` helps to remove floaters in areas of the shape that are not supervised by the application objective, such as internal faces when using image supervision only. +* The L_dev loss at `L105` can be increased if you observe artifacts in flat areas, as illustrated in the image below. +* Generally, the L1 regularizer on flexible weights at `L106` does not have a significant impact during the optimization of a single shape. However, we found it to be effective in stabilizing training in generative pipelines such as GET3D. +Ablating L_dev + +### Resolution of voxel grid vs. tetrahedral grid: +If you are switching from our previous work, DMTet, it's important to note the difference in grid resolution when compared to FlexiCubes. In both implementations, the resolution is defined by the edge length: a grid resolution of `n` means the grid edge length is 1/n for both the voxel and tetrahedral grids. However, a tetrahedral grid with a resolution of `n` contains only `(n/2+1)³` grid vertices, in contrast to the `(n+1)³` vertices in a voxel grid. Consequently, if you are switching from DMTet to FlexiCubes while maintaining the same resolution, you will notice not only a denser output mesh but also a substantial increase in computational cost. To align the triangle count in the output meshes more closely, we recommend adopting a 4:5 resolution ratio between the voxel grid and the tetrahedral grid. For instance, in our paper, `64³` FlexiCubes generate approximately the same number of triangles as `80³` DMTet. + +## Applications +FlexiCubes is now integrated into NVIDIA applications as a drop-in replacement for DMTet. You can visit their GitHub pages to see how FlexiCubes is used in advanced photogrammetry and 3D generative pipelines. + +[Extracting Triangular 3D Models, Materials, and Lighting From Images (nvdiffrec)](https://github.com/NVlabs/nvdiffrec#news) + +[GET3D: A Generative Model of High Quality 3D Textured Shapes Learned from Images](https://github.com/nv-tlabs/GET3D#employing-flexicubes) + + + +## License +Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + +This work is made available under the [Nvidia Source Code License](LICENSE.txt). + +For business inquiries, please visit our website and submit the form: [NVIDIA Research Licensing](https://www.nvidia.com/en-us/research/inquiries/). + +## Citation +```bibtex +@article{shen2023flexicubes, +author = {Shen, Tianchang and Munkberg, Jacob and Hasselgren, Jon and Yin, Kangxue and Wang, Zian + and Chen, Wenzheng and Gojcic, Zan and Fidler, Sanja and Sharp, Nicholas and Gao, Jun}, +title = {Flexible Isosurface Extraction for Gradient-Based Mesh Optimization}, +year = {2023}, +issue_date = {August 2023}, +publisher = {Association for Computing Machinery}, +address = {New York, NY, USA}, +volume = {42}, +number = {4}, +issn = {0730-0301}, +url = {https://doi.org/10.1145/3592430}, +doi = {10.1145/3592430}, +journal = {ACM Trans. Graph.}, +month = {jul}, +articleno = {37}, +numpages = {16} +} +``` diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/data/inputmodels/block.obj b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/data/inputmodels/block.obj new file mode 100644 index 0000000000000000000000000000000000000000..2e047a63ab629597fb07f7620b97bd9806fc918c --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/data/inputmodels/block.obj @@ -0,0 +1,6420 @@ +#### +# +# OBJ File Generated by Meshlab +# +#### +# Object block.obj +# +# Vertices: 2132 +# Faces: 4272 +# +#### +v -0.165639 -5.573223 -18.999933 +v -0.461723 -6.632682 -18.999977 +v -1.123145 -5.856486 -18.999767 +v 1.337052 -5.619015 -19.000029 +v 0.762372 -6.350244 -18.999895 +v 2.820900 -5.742386 -18.999819 +v 2.408428 -6.366748 -18.999821 +v 4.120584 -5.888971 -18.999855 +v 4.075361 -6.620109 -18.999723 +v 5.162054 -5.604235 -18.999794 +v 4.564273 -6.432123 -18.999977 +v 5.177588 -6.145572 -18.999548 +v -1.476656 -4.572156 -18.999788 +v -2.073483 -5.835238 -18.999626 +v -2.616405 -4.620805 -18.999660 +v -0.231328 -4.398811 -18.999969 +v 0.882585 -4.640382 -19.000013 +v 2.276970 -4.703317 -19.000065 +v 3.658001 -4.746932 -19.000027 +v 4.911416 -4.703702 -18.999893 +v 6.026997 -5.384893 -18.999716 +v 6.311928 -4.527776 -18.999842 +v 6.883448 -4.824081 -18.999786 +v -2.944314 -3.165492 -18.999743 +v -3.878798 -4.092359 -18.999636 +v -3.977383 -3.167244 -18.999697 +v -1.602759 -3.083865 -19.000050 +v -0.533028 -3.338088 -19.000050 +v 0.747356 -3.399177 -19.000040 +v 2.094094 -3.433646 -19.000071 +v 3.477786 -3.443073 -19.000105 +v 4.843198 -3.434270 -19.000044 +v 6.201754 -3.419271 -18.999908 +v 7.346195 -3.962304 -18.999708 +v 7.205399 -3.473065 -18.999910 +v 7.773500 -3.648923 -18.999828 +v -4.186573 -1.976305 -18.999887 +v -4.798323 -2.368695 -18.999729 +v -5.006764 -1.656656 -18.999937 +v -3.002518 -1.741401 -18.999868 +v -1.917867 -1.963628 -19.000002 +v -0.635057 -2.025666 -19.000088 +v 0.701450 -2.058856 -19.000067 +v 2.070887 -2.067044 -19.000055 +v 3.448277 -2.068965 -19.000088 +v 4.820169 -2.071731 -19.000107 +v 6.094645 -2.116445 -18.999996 +v 7.086842 -2.324033 -18.999861 +v 7.802579 -2.716221 -19.000017 +v -4.415977 -0.716459 -18.999849 +v -5.179081 -0.746684 -18.999792 +v -3.275583 -0.744755 -18.999821 +v -2.014131 -0.664914 -18.999922 +v -0.677856 -0.679602 -19.000038 +v 0.691577 -0.687734 -19.000061 +v 2.068966 -0.689655 -19.000048 +v 3.448277 -0.689655 -19.000057 +v 4.820041 -0.692442 -19.000082 +v 6.094861 -0.736049 -19.000027 +v 7.068658 -0.935413 -18.999882 +v 7.805267 -1.405900 -18.999884 +v -4.419942 0.746970 -18.999763 +v -5.201444 0.504959 -18.999733 +v -3.397708 0.595431 -18.999805 +v -2.056776 0.677680 -18.999928 +v -0.687734 0.691576 -19.000017 +v 0.689656 0.689656 -19.000044 +v 2.068966 0.689656 -19.000032 +v 3.446356 0.687735 -19.000015 +v 4.810293 0.684958 -19.000025 +v 6.083338 0.654945 -19.000025 +v 7.068028 0.477729 -18.999941 +v 7.786904 0.107304 -18.999905 +v -4.538282 1.938491 -18.999763 +v -5.003533 1.713495 -18.999290 +v -3.571108 1.923630 -18.999743 +v -2.075072 2.049625 -18.999943 +v -0.689655 2.068966 -19.000042 +v 0.689656 2.068966 -19.000063 +v 2.067045 2.067045 -19.000021 +v 3.434908 2.062380 -18.999950 +v 4.759802 2.039359 -18.999901 +v 6.000494 2.036689 -18.999926 +v 7.062859 1.973648 -18.999969 +v 7.787110 1.630417 -18.999935 +v -4.777190 2.401598 -18.999893 +v -4.342964 3.377796 -18.999943 +v -3.637575 3.038409 -18.999880 +v -2.063604 3.313786 -18.999937 +v -0.710220 3.420887 -19.000029 +v 0.666008 3.441584 -19.000093 +v 2.045688 3.437157 -19.000040 +v 3.392011 3.418610 -18.999918 +v 4.650108 3.397501 -18.999823 +v 5.674852 3.215365 -18.999809 +v 6.814051 3.379959 -18.999891 +v 8.068855 3.130511 -19.000080 +v -3.204801 4.177232 -18.999821 +v -2.708986 4.863453 -18.999645 +v -2.178935 4.494017 -18.999790 +v -0.781654 4.635417 -18.999968 +v 0.525132 4.698227 -19.000046 +v 1.902239 4.709037 -19.000050 +v 3.311563 4.717488 -18.999939 +v 4.344522 4.539327 -18.999840 +v 5.612260 4.739365 -18.999855 +v 6.657412 4.681859 -18.999718 +v 7.600099 3.945461 -18.999701 +v -1.890565 5.407166 -18.999786 +v -1.280917 6.293409 -18.999954 +v -0.973609 5.590141 -18.999937 +v 0.199929 5.697699 -18.999987 +v 1.529724 5.636674 -19.000013 +v 3.030383 5.703650 -18.999973 +v 4.500709 5.768940 -18.999914 +v 5.364489 6.029878 -18.999949 +v 6.033417 5.590828 -18.999685 +v -0.241275 6.696087 -18.999952 +v 1.037525 6.362198 -18.999889 +v 2.663652 6.375185 -18.999886 +v 4.185058 6.585073 -18.999950 +v 4.804520 6.330125 -18.999788 +v -0.421235 -6.656398 -17.394541 +v -1.325104 -6.282555 -18.999352 +v 0.679138 -6.941752 -18.998863 +v 2.219468 -7.013837 -18.999493 +v 3.523093 -6.803488 -18.999224 +v 4.469324 -6.485635 -18.998613 +v 5.353630 -6.048399 -17.350197 +v -2.210487 -5.760900 -18.996775 +v -3.023957 -5.085801 -18.999786 +v 6.141503 -5.516292 -18.998859 +v 6.865561 -4.854255 -17.475771 +v -3.731118 -4.322264 -18.997108 +v -4.339971 -3.406544 -18.999203 +v 7.481360 -4.116399 -18.998747 +v 7.969987 -3.332854 -18.999718 +v -4.728674 -2.563595 -17.297010 +v -5.031064 -1.596630 -18.129869 +v 8.411844 -2.353575 -18.999949 +v -5.208095 -0.470022 -17.866573 +v 8.757138 -1.012049 -18.999840 +v -5.185600 0.701961 -17.534266 +v 8.808786 0.585674 -18.999817 +v -5.011068 1.673966 -17.017660 +v 8.491404 2.150793 -18.999369 +v -4.722659 2.579336 -18.998030 +v -4.282218 3.503800 -17.424923 +v 8.044873 3.200831 -17.962170 +v -3.780249 4.254243 -18.999582 +v -2.970770 5.149286 -18.998568 +v 6.869936 4.852803 -18.998613 +v 7.500493 4.090209 -17.228884 +v -2.067351 5.850922 -18.999632 +v -1.364075 6.261341 -17.414753 +v 5.385894 6.027542 -18.328382 +v 6.195252 5.467305 -17.418821 +v -0.437590 6.653239 -18.997763 +v 0.715309 6.946962 -18.999067 +v 2.253762 7.011704 -18.999500 +v 3.566900 6.792746 -18.999182 +v 4.551359 6.448752 -18.204193 +v -0.410703 -6.661936 -15.520120 +v -1.355857 -6.264984 -16.619106 +v 0.723711 -6.942080 -16.014507 +v 1.991220 -7.027766 -16.342434 +v 3.315130 -6.860070 -16.499054 +v 4.440370 -6.502453 -16.750357 +v 5.340881 -6.054998 -15.630901 +v -2.255679 -5.725521 -15.740212 +v -3.022705 -5.097826 -16.715780 +v 6.135752 -5.513404 -16.506947 +v 6.863369 -4.856042 -15.683711 +v -3.722247 -4.328760 -15.713997 +v -4.295989 -3.474068 -16.517559 +v 7.501554 -4.089353 -16.818617 +v 8.053320 -3.185141 -16.612186 +v -4.717000 -2.594954 -15.620216 +v -5.030748 -1.610578 -16.584778 +v 8.512047 -2.073994 -16.704716 +v -5.203835 -0.526693 -16.117393 +v 8.806722 -0.652415 -16.739500 +v -5.196726 0.593576 -15.773910 +v 8.783015 0.846560 -16.582325 +v -5.017540 1.658304 -15.395155 +v 8.503728 2.097052 -16.305576 +v -4.713121 2.605515 -16.397495 +v -4.270517 3.519660 -15.651779 +v 8.066547 3.163192 -15.880778 +v -3.695637 4.363139 -16.583355 +v -3.008401 5.108599 -15.770120 +v 6.906489 4.807900 -16.490080 +v 7.536606 4.038611 -15.443035 +v -2.225489 5.745513 -16.678457 +v -1.363050 6.262885 -15.499363 +v 5.377783 6.035960 -16.676319 +v 6.183223 5.477926 -15.659595 +v -0.390271 6.668847 -15.842120 +v 0.736952 6.943652 -16.126841 +v 2.001362 7.026815 -16.344479 +v 3.324223 6.858053 -16.382347 +v 4.452676 6.496666 -16.346155 +v -0.408345 -6.663945 -13.954590 +v -1.404649 -6.241850 -14.862558 +v 0.750153 -6.947196 -14.328809 +v 2.050089 -7.024825 -14.520862 +v 3.320537 -6.858996 -14.731099 +v 4.424042 -6.508613 -15.046970 +v 5.322532 -6.065605 -14.121890 +v -2.274212 -5.711545 -14.154254 +v -3.039441 -5.079315 -14.894130 +v 6.133159 -5.517176 -14.851393 +v 6.860979 -4.858759 -14.133094 +v -3.719398 -4.332030 -14.156790 +v -4.285974 -3.491872 -14.866487 +v 7.510243 -4.077416 -15.059217 +v 8.060410 -3.174897 -14.742910 +v -4.714750 -2.600443 -14.127056 +v -5.020209 -1.647209 -14.990906 +v 8.524588 -2.042871 -14.667617 +v -5.197890 -0.577524 -14.606171 +v 8.804032 -0.665392 -14.637739 +v -5.198924 0.568878 -14.301943 +v 8.794391 0.733384 -14.563951 +v -5.022644 1.642696 -13.918367 +v 8.526978 2.029423 -14.486143 +v -4.707623 2.619859 -14.834816 +v -4.262901 3.532387 -14.144992 +v 8.087508 3.120808 -14.308061 +v -3.689566 4.370242 -14.888531 +v -2.998945 5.117379 -14.158689 +v 6.908790 4.808465 -14.833581 +v 7.547887 4.023495 -13.954211 +v -2.227340 5.744803 -14.877048 +v -1.346685 6.272311 -13.957561 +v 5.366254 6.040805 -15.014498 +v 6.180680 5.480055 -14.133834 +v -0.372490 6.674899 -14.307992 +v 0.766306 6.948890 -14.450423 +v 2.070075 7.024910 -14.496114 +v 3.334786 6.856692 -14.617575 +v 4.443177 6.501784 -14.721889 +v -0.318432 -6.695818 -12.163453 +v -1.397950 -6.246614 -13.344915 +v 0.823404 -6.958866 -12.637669 +v 2.053232 -7.023069 -12.946634 +v 3.313560 -6.858580 -13.092209 +v 4.414396 -6.511841 -13.444628 +v 5.312486 -6.072024 -12.391240 +v -2.265884 -5.717878 -12.649908 +v -3.040109 -5.078373 -13.439447 +v 6.121315 -5.526526 -13.305403 +v 6.846072 -4.873465 -12.415820 +v -3.729314 -4.321495 -12.677643 +v -4.286255 -3.491529 -13.393528 +v 7.500516 -4.090383 -13.478516 +v 8.055758 -3.186780 -13.169513 +v -4.707448 -2.613953 -12.464479 +v -5.017308 -1.657663 -13.363405 +v 8.515320 -2.078118 -13.051853 +v -5.193908 -0.627830 -12.985748 +v 8.794633 -0.745398 -12.995745 +v -5.205478 0.504980 -12.559045 +v 8.801219 0.664622 -13.034389 +v -5.019536 1.655098 -12.191317 +v 8.549723 1.958513 -12.951862 +v -4.704885 2.627878 -13.334602 +v -4.261400 3.534135 -12.619902 +v 8.111174 3.075566 -12.749157 +v -3.687815 4.372269 -13.432957 +v -3.003130 5.113585 -12.698553 +v 6.917823 4.798900 -13.298219 +v 7.572776 3.990231 -12.247713 +v -2.222056 5.749259 -13.381355 +v -1.321282 6.285887 -12.211472 +v 5.377876 6.033880 -13.485123 +v 6.203483 5.460897 -12.443540 +v -0.267109 6.711230 -12.500576 +v 0.847614 6.961692 -12.779180 +v 2.072503 7.022956 -12.870871 +v 3.388499 6.844315 -12.868088 +v 4.484243 6.484571 -13.064227 +v -0.400608 -6.675842 -10.000947 +v -1.367807 -6.261198 -11.601811 +v 0.891959 -6.969805 -10.002173 +v 2.111283 -7.016342 -10.002074 +v 3.299979 -6.861220 -10.002430 +v 4.379614 -6.526729 -11.461821 +v 5.276550 -6.099892 -10.001004 +v -2.257809 -5.722184 -11.058659 +v -3.038298 -5.082352 -11.920617 +v 6.122053 -5.525905 -11.515967 +v 6.853882 -4.865211 -10.782982 +v -3.755836 -4.287035 -11.108328 +v -4.316311 -3.437725 -11.722515 +v 7.466073 -4.135733 -11.576698 +v 8.020292 -3.251613 -11.017416 +v -4.716969 -2.594116 -10.000961 +v -4.999873 -1.719877 -11.342630 +v 8.503738 -2.100134 -11.068405 +v -5.189658 -0.725674 -10.001967 +v 8.786741 -0.777212 -11.326254 +v -5.204514 0.603583 -10.001227 +v 8.802476 0.611000 -11.369303 +v -4.964613 1.876791 -10.000495 +v 8.560858 1.909610 -11.149176 +v -4.689806 2.659680 -11.644715 +v -4.241360 3.564041 -11.021438 +v 8.137661 3.018310 -10.812011 +v -3.687264 4.374627 -11.898881 +v -2.964126 5.151313 -11.181742 +v 6.936994 4.779319 -11.518385 +v 7.583722 3.980274 -10.000742 +v -2.223717 5.746185 -11.777360 +v -1.401633 6.243301 -10.002298 +v 5.428456 6.003206 -11.656769 +v 6.224125 5.443000 -10.799882 +v -0.285183 6.713306 -10.002426 +v 0.964337 6.977686 -10.001996 +v 2.133778 7.014220 -10.001637 +v 3.348632 6.854147 -10.001760 +v 4.504269 6.478266 -11.048509 +v -0.720948 -6.928852 -9.999931 +v -1.594241 -6.136552 -10.000312 +v 0.439274 -6.867991 -9.999896 +v 1.688904 -7.000162 -10.000152 +v 2.840354 -6.923121 -10.000202 +v 4.260046 -6.563911 -10.000011 +v 5.445410 -6.305882 -9.999956 +v -2.289205 -5.689465 -10.000236 +v -3.070853 -5.058268 -10.001080 +v 6.214115 -5.449193 -10.000143 +v 6.858390 -4.849928 -9.999802 +v -3.758603 -4.267620 -10.000113 +v -4.246625 -3.552272 -10.000269 +v 7.516863 -4.075599 -10.000308 +v 8.166223 -2.951466 -9.999951 +v -4.986446 -2.756034 -10.000077 +v -4.985199 -1.747506 -9.999954 +v 8.590415 -1.782308 -9.999966 +v -5.193737 -0.356820 -9.999608 +v 8.806740 -0.471123 -10.000157 +v -5.117985 1.087395 -9.999471 +v 8.766995 0.880242 -10.000215 +v -5.302761 2.162848 -9.999762 +v 8.481910 2.150902 -9.999894 +v -4.563984 2.940450 -10.000133 +v -4.124532 3.750248 -10.000196 +v 8.072631 3.128069 -9.999865 +v -3.655359 4.413848 -10.546494 +v -3.022754 5.092469 -10.000499 +v 6.863836 4.852492 -9.999966 +v 7.821033 4.206524 -9.999940 +v -2.219922 5.747849 -10.000394 +v -1.646290 6.094517 -10.000150 +v 5.422164 6.014023 -10.000038 +v 6.230863 5.428445 -9.999673 +v -0.538707 6.608978 -10.000111 +v 0.854227 6.945774 -10.000006 +v 2.015121 7.002833 -10.000026 +v 3.094553 6.886382 -9.999997 +v 4.439874 6.495217 -9.999701 +v -8.197086 -9.997589 -9.999541 +v -8.199067 -9.999600 -8.716067 +v -8.199409 -8.696136 -9.997756 +v -5.781787 -9.997543 -9.999446 +v -6.421419 -9.999472 -9.997104 +v -4.375885 -9.997828 -9.999455 +v -4.955079 -9.999506 -9.997752 +v -3.006303 -9.997700 -9.999463 +v -3.561000 -9.999508 -9.997672 +v -1.652116 -9.997658 -9.999422 +v -2.173668 -9.999477 -9.997780 +v -0.245533 -9.997670 -9.999454 +v -0.784858 -9.999476 -9.997809 +v 1.145544 -9.997683 -9.999497 +v 0.591992 -9.999488 -9.997816 +v 2.520945 -9.997649 -9.999510 +v 1.965135 -9.999486 -9.997804 +v 3.908123 -9.997543 -9.999378 +v 3.348468 -9.999459 -9.997861 +v 5.308175 -9.997520 -9.999248 +v 4.730516 -9.999423 -9.997422 +v 6.678235 -9.997456 -9.999186 +v 6.109396 -9.999385 -9.997457 +v 8.080564 -9.997587 -9.999315 +v 7.500117 -9.999391 -9.997400 +v 9.617836 -9.997139 -9.999391 +v 9.001713 -9.999300 -9.997132 +v 11.797565 -9.057693 -10.000415 +v 10.597147 -9.999520 -9.998665 +v 11.799543 -8.799160 -9.997790 +v 11.799539 -9.998816 -9.998493 +v 11.799337 -9.038968 -8.606289 +v -8.198895 -7.742308 -9.999577 +v -8.199457 -7.628617 -9.257527 +v -6.284545 -7.792484 -9.999421 +v -4.766076 -7.805584 -9.999451 +v -3.413266 -7.854074 -9.999515 +v -2.270303 -8.138656 -9.999458 +v -0.871405 -7.838208 -9.999558 +v 0.722910 -8.127664 -9.999661 +v 2.045268 -8.146546 -9.999733 +v 3.346699 -8.054918 -9.999661 +v 4.978243 -7.632292 -9.999560 +v 6.414917 -7.733258 -9.999399 +v 7.753506 -7.708609 -9.999392 +v 9.273371 -7.692310 -9.999468 +v 10.817455 -7.789749 -9.999403 +v 11.799412 -7.779394 -9.999247 +v 11.799374 -8.133942 -8.664234 +v -8.198868 -6.315583 -9.999582 +v -8.199468 -5.925711 -9.996849 +v -6.563265 -6.374945 -9.999517 +v -4.937477 -6.410377 -9.999699 +v -3.769089 -6.645193 -9.999577 +v -2.309842 -6.564626 -9.999692 +v 6.466720 -6.127551 -9.999690 +v 7.717245 -6.186673 -9.999544 +v 9.146501 -6.146393 -9.999430 +v 10.777307 -6.236406 -9.999344 +v 11.799574 -6.395100 -9.999305 +v 11.799397 -6.882066 -8.766532 +v -8.197493 -4.905184 -9.999464 +v -8.199444 -4.531807 -9.996873 +v -6.661044 -5.053992 -9.999547 +v -5.173023 -5.397469 -9.999743 +v -3.614792 -5.279174 -9.999962 +v 7.822600 -4.723773 -9.999763 +v 9.148055 -4.696765 -9.999522 +v 10.772377 -4.827792 -9.999338 +v 11.799680 -5.023424 -9.999307 +v 11.799520 -5.529768 -8.802168 +v -8.197610 -3.625628 -9.999538 +v -8.199486 -3.165943 -9.997169 +v -6.794203 -3.993701 -9.999626 +v -5.025950 -4.000316 -9.999805 +v 9.154870 -2.849803 -9.999709 +v 10.765962 -3.353853 -9.999418 +v 11.799719 -3.640823 -9.999392 +v 11.799555 -4.148968 -8.806036 +v -8.197663 -2.200317 -9.999600 +v -8.199505 -1.782159 -9.997161 +v -6.389792 -2.682891 -9.999742 +v 9.465948 -1.309395 -9.999745 +v 10.767172 -1.890117 -9.999478 +v 11.799747 -2.254328 -9.999434 +v 11.799583 -2.761179 -8.812508 +v -8.197810 -0.848804 -9.999594 +v -8.199508 -0.407458 -9.997053 +v -6.713641 -1.252895 -9.999747 +v 9.470627 0.042371 -9.999876 +v 10.783956 -0.492653 -9.999573 +v 11.799766 -0.870305 -9.999471 +v 11.799607 -1.372826 -8.815663 +v -8.197782 0.504463 -9.999574 +v -8.199501 0.971744 -9.997130 +v -6.811318 0.162145 -9.999670 +v 9.457400 1.391088 -9.999795 +v 10.785440 0.876938 -9.999584 +v 11.799765 0.510227 -9.999487 +v 11.799617 0.012581 -8.814260 +v -8.197620 1.962345 -9.999605 +v -8.199506 2.359677 -9.997253 +v -6.497678 1.852556 -9.999640 +v 9.395690 2.701666 -9.999727 +v 10.788474 2.240891 -9.999500 +v 11.799747 1.889653 -9.999460 +v 11.799599 1.391442 -8.815294 +v -8.197556 3.367060 -9.999596 +v -8.199503 3.748702 -9.997163 +v -6.622739 3.377849 -9.999564 +v -4.939245 3.324420 -9.999815 +v 9.075632 4.154729 -9.999699 +v 10.797721 3.634703 -9.999436 +v 11.799722 3.268076 -9.999415 +v 11.799573 2.768099 -8.814678 +v -8.197506 4.759051 -9.999463 +v -8.199454 5.140103 -9.996816 +v -6.603458 4.752068 -9.999467 +v -4.876116 4.687325 -9.999647 +v -3.596853 4.470874 -10.000001 +v 7.849902 5.360943 -9.999687 +v 9.483107 5.400774 -9.999507 +v 10.781439 4.975497 -9.999344 +v 11.799677 4.646227 -9.999357 +v 11.799533 4.148460 -8.808810 +v -8.197443 6.167029 -9.999425 +v -8.199409 6.531978 -9.997680 +v -6.604771 6.149668 -9.999390 +v -4.936182 6.135021 -9.999449 +v -3.572213 6.092749 -9.999702 +v -2.451163 5.953185 -9.999896 +v 6.402214 6.673689 -9.999610 +v 7.945500 6.708607 -9.999544 +v 9.209959 6.438878 -9.999479 +v 10.795531 6.279743 -9.999340 +v 11.799589 6.021252 -9.999226 +v 11.799470 5.520098 -8.804151 +v -8.198523 7.587330 -9.999629 +v -8.199303 7.724271 -8.980122 +v -6.594853 7.664030 -9.999280 +v -5.036320 7.640518 -9.999417 +v -3.597762 7.712246 -9.999355 +v -2.270836 7.726063 -9.999474 +v -0.922407 7.756612 -9.999634 +v 0.655862 8.068737 -9.999626 +v 1.925484 8.155303 -9.999682 +v 3.192561 8.125588 -9.999692 +v 4.854494 7.877717 -9.999579 +v 6.407773 8.204655 -9.999369 +v 7.555892 7.894943 -9.999517 +v 8.989082 7.847031 -9.999428 +v 10.603476 7.721271 -9.999468 +v 11.799506 7.418404 -9.999415 +v 11.799397 6.877194 -8.799346 +v -8.199263 8.903291 -9.999499 +v -8.199424 9.997242 -8.599353 +v -6.731197 9.997187 -9.999447 +v -5.286429 9.997339 -9.999399 +v -3.873603 9.997865 -9.999288 +v -2.493809 9.997478 -9.999219 +v -1.129630 9.997541 -9.999272 +v 0.257248 9.997542 -9.999388 +v 1.641368 9.997647 -9.999502 +v 3.017100 9.997674 -9.999477 +v 4.419827 9.997665 -9.999426 +v 5.835939 9.997657 -9.999381 +v 7.191218 9.997732 -9.999430 +v 8.577856 9.997912 -9.999694 +v 10.125374 9.997486 -9.999679 +v 11.799546 8.793805 -9.999454 +v 11.799381 8.257704 -8.761130 +v -8.197162 9.999694 -9.997536 +v -5.842711 9.999352 -9.997362 +v -4.418329 9.999475 -9.997643 +v -3.038747 9.999500 -9.997452 +v -1.665510 9.999434 -9.997465 +v -0.284061 9.999464 -9.997411 +v 1.094400 9.999503 -9.997859 +v 2.470650 9.999520 -9.997791 +v 3.856460 9.999516 -9.997779 +v 5.245696 9.999507 -9.997786 +v 6.628714 9.999508 -9.997760 +v 8.016776 9.999541 -9.997634 +v 9.464401 9.999571 -9.998288 +v 11.798951 9.999917 -9.997349 +v 11.799402 9.315673 -8.675556 +v -8.198434 -9.999648 -7.275680 +v -8.199415 -9.008153 -8.183144 +v -6.535277 -9.999402 -7.615333 +v -4.974464 -9.999445 -7.764457 +v -3.569772 -9.999507 -7.744366 +v -2.201797 -9.999516 -7.681486 +v -0.678205 -9.999609 -7.678342 +v 0.720812 -9.999534 -7.758585 +v 2.002483 -9.999392 -7.709468 +v 3.358394 -9.999538 -7.650822 +v 4.784429 -9.999563 -7.705940 +v 6.140139 -9.999550 -7.698178 +v 7.521829 -9.999500 -7.680385 +v 9.007818 -9.999413 -7.628045 +v 10.608386 -9.999270 -7.831657 +v 11.799378 -9.999377 -8.044714 +v 11.799425 -8.888695 -7.639390 +v -8.199463 -7.607832 -7.807794 +v 11.799430 -7.715961 -7.507819 +v -8.199475 -6.133699 -7.660379 +v 11.799476 -6.394962 -7.538971 +v -8.199500 -4.755322 -7.633470 +v 11.799466 -5.022318 -7.543217 +v -8.199518 -3.389469 -7.641518 +v 11.799461 -3.595009 -7.567367 +v -8.199512 -2.018294 -7.650225 +v 11.799475 -2.114996 -7.625445 +v -8.199518 -0.652008 -7.666768 +v 11.799520 -0.739170 -7.610875 +v -8.199518 0.718899 -7.679207 +v 11.799486 0.617350 -7.588253 +v -8.199525 2.073963 -7.680296 +v 11.799434 2.017823 -7.625350 +v -8.199538 3.550204 -7.660015 +v 11.799444 3.405694 -7.607674 +v -8.199531 5.009249 -7.675735 +v 11.799396 4.784847 -7.568297 +v -8.199511 6.333641 -7.650737 +v 11.799357 6.061503 -7.568983 +v -8.199471 7.734221 -7.516476 +v 11.799384 7.356416 -7.587458 +v -8.199567 9.173730 -7.057881 +v 11.799429 8.684653 -7.640934 +v -8.199142 9.999617 -7.637571 +v -6.296588 9.999453 -7.771146 +v -4.752046 9.999473 -7.762884 +v -3.384683 9.999565 -7.749969 +v -2.106153 9.999585 -7.687098 +v -0.694825 9.999597 -7.668640 +v 0.710558 9.999669 -7.723806 +v 1.988463 9.999670 -7.727983 +v 3.367740 9.999622 -7.728632 +v 4.866497 9.999627 -7.728609 +v 6.327654 9.999587 -7.730477 +v 7.733594 9.999537 -7.709217 +v 9.232080 9.999465 -7.644510 +v 10.816275 9.999367 -7.719549 +v 11.799520 9.998780 -7.696483 +v -8.197535 -9.999454 -5.876680 +v -8.199384 -9.997172 -6.648834 +v -6.615159 -9.999591 -6.172308 +v -4.928238 -9.999508 -6.287317 +v -3.493124 -9.999625 -6.290891 +v -2.396800 -9.999622 -6.545432 +v -0.931823 -9.999562 -6.182242 +v 1.278400 -9.999836 -5.987411 +v 2.066704 -9.999538 -6.002573 +v 3.121100 -9.999532 -6.412695 +v 4.922377 -9.999692 -6.000663 +v 6.268679 -9.999669 -6.097210 +v 7.593183 -9.999622 -6.181079 +v 9.093877 -9.999564 -6.156287 +v 10.763025 -9.999396 -6.294472 +v 11.799572 -9.999108 -6.694769 +v 11.799508 -8.815783 -6.345116 +v -8.199471 -7.647173 -6.365884 +v 11.799492 -7.558034 -6.179054 +v -8.199493 -6.210351 -6.230461 +v 11.799470 -6.223871 -6.213104 +v -8.199518 -4.872240 -6.195818 +v 11.799449 -4.840047 -6.258850 +v -8.199504 -3.440536 -6.058222 +v 11.799455 -3.104877 -6.374187 +v -8.199571 -1.904626 -6.408732 +v 11.799479 -1.503608 -6.644092 +v -8.199664 -0.488334 -6.579994 +v 11.799407 -0.206462 -6.528683 +v -8.199561 0.826927 -6.558948 +v 11.799545 1.034986 -6.599732 +v -8.199677 2.090771 -6.503613 +v 11.799541 2.516534 -6.622082 +v -8.199618 3.778229 -6.316415 +v 11.799479 4.065857 -6.285263 +v -8.199558 5.195997 -6.611563 +v 11.799401 5.281944 -6.523500 +v -8.199549 6.319622 -6.324531 +v 11.799391 6.328523 -6.305669 +v -8.199545 7.696940 -6.106700 +v 11.799361 7.548317 -6.319578 +v -8.199562 9.997359 -5.592088 +v 11.799398 8.803955 -6.274086 +v -8.199135 9.999597 -6.202177 +v -6.549465 9.999495 -6.322655 +v -4.876023 9.999579 -6.275066 +v -3.540742 9.999563 -6.314503 +v -2.587391 9.999701 -6.367679 +v -1.332323 9.999681 -5.968807 +v 0.394105 9.999797 -5.834267 +v 1.522830 9.999822 -5.994208 +v 2.656445 9.999740 -5.940061 +v 4.309387 9.999720 -6.268180 +v 6.101918 9.999698 -6.246173 +v 7.610718 9.999632 -6.211280 +v 9.132327 9.999571 -6.150370 +v 10.771190 9.999393 -6.209607 +v 11.799554 9.999144 -6.305787 +v -8.197595 -9.999343 -4.504618 +v -8.199450 -9.997026 -5.266454 +v -6.631415 -9.999523 -4.845931 +v -4.941531 -9.999628 -4.975726 +v -3.662716 -9.999701 -5.211709 +v -1.940732 -9.999906 -4.722961 +v -0.645099 -9.998431 -5.521235 +v -1.598355 -8.841139 -4.971010 +v 0.798045 -9.998487 -5.942139 +v 2.019213 -9.438328 -6.019917 +v 3.224112 -9.998937 -5.865794 +v 4.545057 -9.999508 -5.360658 +v 5.387156 -9.999788 -4.821813 +v 6.392444 -9.999743 -4.652799 +v 7.634109 -9.999722 -4.654175 +v 9.116672 -9.999655 -4.744941 +v 10.775377 -9.999466 -4.892883 +v 11.799663 -9.999146 -5.310978 +v 11.799561 -8.806577 -4.974324 +v -8.199500 -7.661956 -4.976057 +v -0.543789 -7.701827 -5.553311 +v -1.542051 -7.184879 -5.009714 +v 0.646769 -7.906864 -5.923930 +v 2.029990 -7.931121 -6.030923 +v 3.285709 -8.127055 -5.846401 +v 4.392823 -8.553043 -5.442753 +v 5.402434 -8.986953 -4.827029 +v 11.799483 -7.536067 -4.814019 +v -8.199533 -6.254948 -4.795567 +v -0.527092 -6.065255 -5.560897 +v -1.563319 -5.613705 -4.992757 +v 0.710227 -6.233649 -5.934304 +v 2.059214 -6.282635 -6.031727 +v 3.469013 -6.274006 -5.803403 +v 4.576782 -6.586240 -5.352248 +v 5.610687 -6.981803 -4.682505 +v 11.799457 -6.214878 -4.912851 +v -8.199594 -4.948255 -4.608037 +v -0.660150 -4.410936 -5.510384 +v -1.734805 -4.511937 -4.863873 +v 0.687797 -4.767218 -5.932472 +v 2.096220 -4.800875 -6.029942 +v 3.526148 -4.702438 -5.790080 +v 4.878107 -4.632379 -5.195413 +v 5.805358 -5.122348 -4.514281 +v 11.799598 -4.772633 -5.058008 +v -8.199823 -3.812617 -4.649699 +v -8.199636 -2.744853 -5.355632 +v -8.197799 -3.803494 -4.671632 +v -6.570097 -3.037490 -5.197766 +v -5.579249 -3.911978 -4.574214 +v -4.481239 -3.057892 -5.190363 +v -3.686859 -3.993152 -4.504757 +v -2.887286 -3.156627 -5.131179 +v -2.198124 -4.007034 -4.487400 +v -1.394477 -3.196192 -5.103760 +v -0.417270 -3.049803 -5.599401 +v 0.704127 -3.310611 -5.934994 +v 2.103781 -3.385201 -6.030068 +v 3.483100 -3.357221 -5.796082 +v 4.704433 -2.866597 -5.280302 +v 5.864598 -4.061251 -4.428973 +v 5.112216 -3.321455 -5.027540 +v 7.010955 -4.103302 -4.414215 +v 8.136370 -3.069519 -5.183742 +v 8.856155 -4.027049 -4.485490 +v 9.960790 -3.003553 -5.225338 +v 10.610147 -3.918534 -4.569955 +v 11.798901 -3.011030 -5.229120 +v 11.799867 -3.959053 -4.521823 +v 11.799586 -3.334645 -5.561627 +v -8.199663 -1.601270 -5.805870 +v -7.004556 -1.965991 -5.694755 +v -4.845649 -1.964663 -5.701309 +v -3.270373 -1.996202 -5.692004 +v -1.878373 -2.087085 -5.661844 +v -0.271080 -2.078768 -5.657950 +v 0.689090 -2.017582 -5.931833 +v 2.086140 -2.030938 -6.029613 +v 3.355649 -1.497195 -5.818519 +v 3.824382 -2.043119 -5.667521 +v 6.120123 -2.106119 -5.655799 +v 7.734968 -2.044835 -5.678695 +v 9.451074 -1.914524 -5.720321 +v 11.076477 -1.838660 -5.744744 +v 11.799584 -1.916953 -5.702216 +v -8.199286 -0.265202 -6.022649 +v -6.819282 -0.707609 -5.990512 +v -4.985128 -0.710446 -5.993889 +v -3.432094 -0.675685 -5.996766 +v -2.005813 -0.700454 -5.996704 +v -0.657409 -0.737507 -5.994256 +v 0.983770 -0.642090 -5.987838 +v 1.873320 -0.349933 -6.018587 +v 2.461001 -0.601646 -5.989651 +v 4.776545 -0.725026 -5.992097 +v 6.143940 -0.744991 -5.992860 +v 7.602170 -0.724354 -5.994216 +v 9.183177 -0.653566 -6.000018 +v 11.012054 -0.649617 -5.990694 +v 11.799411 -0.882933 -5.953003 +v -8.199474 1.071286 -5.926068 +v -6.786499 0.677417 -5.992784 +v -4.989926 0.655453 -6.000698 +v -3.446477 0.718845 -5.994532 +v -2.005364 0.734130 -5.993684 +v -0.644731 0.706743 -5.995169 +v 1.269274 0.555561 -5.995363 +v 2.152885 0.593043 -5.999925 +v 3.450587 0.746895 -5.993968 +v 4.773715 0.714711 -5.997985 +v 6.168500 0.678442 -5.998556 +v 7.619453 0.683036 -5.996651 +v 9.192253 0.689896 -5.994837 +v 10.951191 0.604808 -5.993295 +v 11.799452 0.196182 -6.011107 +v -8.199618 2.074471 -5.640577 +v -7.064785 1.960899 -5.697335 +v -5.192454 1.939865 -5.711124 +v -3.571444 2.043488 -5.678872 +v -1.995842 2.090984 -5.660890 +v -0.116349 1.962943 -5.693911 +v 0.740772 1.063983 -5.928383 +v 2.093983 2.059163 -6.031731 +v 3.468668 1.566100 -5.800748 +v 3.913185 2.182983 -5.632794 +v 6.030447 2.104294 -5.660509 +v 7.466060 1.972247 -5.698761 +v 9.088945 1.958584 -5.701531 +v 11.797971 1.896790 -5.724948 +v 11.799903 1.091409 -5.908539 +v -8.199558 3.150676 -5.113977 +v -8.197059 2.999491 -5.228165 +v -5.742509 3.027697 -5.208352 +v -3.936587 3.084698 -5.174985 +v -1.445709 3.282105 -5.054072 +v -0.690656 2.457887 -5.489321 +v 0.639774 3.374856 -5.923337 +v 2.054134 3.374554 -6.033294 +v 3.472083 3.269565 -5.799263 +v 4.485263 2.668436 -5.386291 +v 5.145700 3.387022 -4.988523 +v 7.072347 3.136822 -5.146075 +v 8.731404 3.038434 -5.199675 +v 10.499704 2.983730 -5.229940 +v 11.799774 2.862498 -5.285520 +v -8.199397 3.950810 -4.551408 +v -8.199591 4.978357 -5.210742 +v -6.523861 3.917865 -4.571984 +v -4.594098 3.939095 -4.552960 +v -2.199405 4.016731 -4.479439 +v -1.995391 3.774898 -4.665979 +v -0.830999 4.698313 -5.437511 +v -1.696721 5.170595 -4.902378 +v 0.596438 4.734746 -5.921164 +v 2.046080 4.820583 -6.032212 +v 3.461160 4.740631 -5.804372 +v 4.765977 4.333749 -5.251219 +v 5.726037 3.915006 -4.549861 +v 5.905932 4.130647 -4.378312 +v 7.961712 3.998636 -4.505661 +v 9.758068 3.873410 -4.607570 +v 11.799082 3.798213 -4.677949 +v 11.799646 4.162864 -5.098303 +v 11.799519 5.314621 -5.097996 +v -8.199535 6.524733 -5.261577 +v -0.553185 6.460670 -5.553912 +v -1.545043 6.794877 -5.014001 +v 0.661656 6.281158 -5.933097 +v 2.087543 6.357923 -6.030626 +v 3.410282 6.363924 -5.814029 +v 4.576826 6.192546 -5.348296 +v 5.565046 5.569194 -4.694882 +v 11.799391 6.606434 -5.193122 +v -8.199544 7.675134 -4.790676 +v -0.382301 8.204876 -5.620165 +v -1.419057 8.504014 -5.090134 +v 0.778209 8.043856 -5.944695 +v 2.127000 8.096928 -6.026480 +v 3.435947 8.361120 -5.802789 +v 4.565781 8.251176 -5.350781 +v 5.533244 7.577791 -4.726126 +v 11.799347 7.592454 -5.026506 +v -8.199542 9.996933 -4.196853 +v -0.437395 9.998920 -5.603590 +v -1.584876 9.999116 -4.974419 +v 0.770631 9.997920 -5.938691 +v 1.987703 9.997864 -6.025558 +v 3.201761 9.998964 -5.858583 +v 4.364268 9.999458 -5.445886 +v 5.479857 9.998835 -4.773780 +v 11.799443 8.805692 -4.886413 +v -8.197565 9.999346 -4.797266 +v -6.631770 9.999530 -4.939600 +v -5.036590 9.999560 -4.927760 +v -3.773880 9.999400 -5.013918 +v -2.277126 9.999526 -4.414088 +v 6.069315 9.999655 -4.944575 +v 7.544839 9.999699 -4.852163 +v 9.112121 9.999648 -4.761281 +v 10.766150 9.999446 -4.817117 +v 11.799642 9.999104 -4.917832 +v -8.197641 -9.999402 -3.126711 +v -8.199480 -9.997170 -3.885499 +v -6.588301 -9.999567 -3.570392 +v -5.072336 -9.999645 -4.052226 +v -2.866430 -9.999930 -3.801252 +v -2.412564 -9.357492 -4.293720 +v -3.028481 -9.079852 -3.590806 +v 6.197879 -9.999116 -4.120582 +v 6.835500 -9.999697 -3.277542 +v 7.621456 -9.999774 -2.990151 +v 9.111020 -9.999665 -3.254164 +v 10.771660 -9.999491 -3.504080 +v 11.799707 -9.999188 -3.930399 +v 11.799583 -8.807912 -3.598260 +v -8.199523 -7.674762 -3.536762 +v -2.361834 -8.124373 -4.347000 +v -3.033801 -7.352487 -3.586731 +v 6.322771 -7.789248 -3.985450 +v 6.870165 -8.651746 -3.244329 +v 11.799481 -7.548273 -3.467424 +v -8.199649 -6.310259 -2.946718 +v -2.413518 -6.259798 -4.301591 +v -3.120787 -6.024586 -3.456293 +v 6.642772 -4.840271 -3.591432 +v 7.089234 -6.588894 -2.874066 +v 11.799521 -6.207240 -3.613254 +v -8.199626 -5.315460 -2.816435 +v -8.199123 -4.621104 -3.871041 +v -7.260527 -5.172211 -3.077703 +v -6.489940 -4.556766 -3.930886 +v -5.179650 -5.127740 -3.145799 +v -4.529086 -4.666463 -3.801405 +v -3.506083 -5.321787 -2.832660 +v -2.881927 -4.681994 -3.780630 +v -2.258030 -4.976668 -4.433399 +v 6.445264 -4.657769 -3.814674 +v 7.189353 -5.394221 -2.651037 +v 7.563098 -4.857209 -3.560855 +v 9.417271 -5.312036 -2.825609 +v 9.812925 -4.685348 -3.783669 +v 11.799013 -5.298687 -2.878169 +v 11.799575 -4.584157 -3.898080 +v 11.799633 -5.610482 -3.139058 +v 11.799736 -5.005306 -4.162315 +v -8.199666 4.674420 -3.778543 +v -8.197265 4.690930 -3.775462 +v -5.520702 4.604403 -3.872566 +v -2.886908 4.703106 -3.759455 +v -2.420707 4.215529 -4.277692 +v 6.188191 4.380233 -4.108079 +v 6.640664 4.870828 -3.555306 +v 8.852288 4.690730 -3.781252 +v 10.593409 4.581908 -3.904963 +v 11.799790 4.523964 -3.956898 +v -8.199712 5.340882 -2.772119 +v -8.199623 6.142515 -3.969742 +v -6.569314 5.171231 -3.076136 +v -4.526580 5.122713 -3.145898 +v -3.414523 5.208680 -3.014136 +v -2.586777 5.680388 -4.133974 +v -3.101949 6.643367 -3.496661 +v 6.385056 6.263601 -3.907426 +v 7.030930 5.217946 -2.966196 +v 7.192600 5.401879 -2.666035 +v 9.859942 5.255906 -2.948375 +v 11.798919 5.229507 -3.009560 +v 11.799566 5.576705 -3.541719 +v 11.799438 6.424042 -3.866938 +v -8.199581 7.670190 -3.416277 +v -2.322645 7.381025 -4.387779 +v -2.954607 8.185115 -3.690625 +v 6.296511 8.518814 -4.008304 +v 6.927417 7.283313 -3.149089 +v 11.799394 7.612821 -3.619348 +v -8.199574 9.996961 -2.816848 +v -2.258032 8.897277 -4.444929 +v -2.896036 9.998099 -3.761736 +v 6.295086 9.999528 -3.993782 +v 6.975959 9.999047 -3.087096 +v 11.799501 8.806191 -3.493371 +v -8.197633 9.999267 -3.420323 +v -6.597630 9.999555 -3.565479 +v -5.260849 9.999516 -3.894366 +v -3.306535 9.999495 -3.169240 +v 7.423060 9.999597 -3.444577 +v 9.070394 9.999636 -3.364267 +v 10.764064 9.999467 -3.436397 +v 11.799677 9.999133 -3.537862 +v -8.197683 -9.999428 -1.745003 +v -8.199496 -9.997220 -2.502029 +v -6.595037 -9.999610 -2.230302 +v -4.649723 -9.999649 -2.795427 +v -3.440007 -9.999244 -2.949142 +v -3.868423 -9.999454 -2.017212 +v 7.565646 -9.999818 -1.685884 +v 7.283952 -9.999390 -2.478088 +v 9.128228 -9.999671 -1.868508 +v 10.770383 -9.999474 -2.114452 +v 11.799734 -9.999207 -2.550586 +v 11.799602 -8.809131 -2.220782 +v -8.199553 -7.699334 -2.066964 +v -3.565838 -8.849984 -2.726726 +v -3.981808 -8.869972 -1.681317 +v 7.357527 -7.945731 -2.300289 +v 11.799492 -7.582936 -2.035713 +v -8.199670 -6.544492 -1.424438 +v -3.586994 -6.740130 -2.686603 +v -3.979078 -5.762631 -1.724067 +v 7.468341 -6.584023 -1.994340 +v 11.799441 -6.588094 -1.980923 +v -8.199616 -5.761811 -1.749310 +v -7.265851 -5.669053 -2.041334 +v -4.827281 -5.710837 -1.961370 +v 7.488700 -5.689359 -1.953416 +v 8.877826 -5.711863 -1.911163 +v 11.076009 -5.754364 -1.788857 +v 11.799593 -5.722426 -1.841136 +v -8.199502 5.793691 -1.643805 +v -8.199743 6.374563 -2.467070 +v -7.022589 5.653299 -2.069438 +v -3.776528 5.589815 -2.234186 +v -3.676234 5.457607 -2.497708 +v -3.988530 5.787000 -1.644971 +v 7.592824 5.797828 -1.611118 +v 7.344422 6.103498 -2.323589 +v 9.281547 5.755380 -1.784792 +v 11.067721 5.747159 -1.828817 +v 11.799597 5.699470 -1.923620 +v 11.799562 6.668055 -2.240345 +v -8.199613 7.689158 -2.021921 +v -3.569395 7.419164 -2.728603 +v -3.960927 7.963889 -1.772748 +v 7.352831 7.922623 -2.310428 +v 11.799465 7.595367 -2.151416 +v -8.199580 9.996964 -1.438756 +v -3.481771 9.079801 -2.888183 +v -3.914362 9.998879 -1.964471 +v 7.413295 9.998059 -2.149808 +v 11.799539 8.808967 -2.098512 +v -8.197672 9.999278 -2.038773 +v -6.647517 9.999584 -2.130324 +v -4.890908 9.999578 -2.337504 +v 7.434996 9.999544 -2.104868 +v 8.858668 9.999474 -2.148045 +v 10.765622 9.999448 -2.063958 +v 11.799701 9.999151 -2.157599 +v -8.197706 -9.999446 -0.370404 +v -8.199528 -9.997251 -1.119840 +v -6.646825 -9.999621 -0.814520 +v -5.133657 -9.999701 -1.318348 +v -4.160445 -9.999633 -0.859341 +v 7.593559 -9.998395 -1.608640 +v 7.750620 -9.999620 -0.840944 +v 8.902712 -9.999626 -0.428918 +v 10.765934 -9.999448 -0.697232 +v 11.799752 -9.999210 -1.169555 +v 11.799613 -8.813197 -0.837518 +v -8.199554 -7.700875 -0.652790 +v -4.197826 -8.771147 -0.561384 +v 7.650217 -7.221619 -1.390286 +v 7.788566 -8.607541 -0.615467 +v 11.799491 -7.640605 -0.629750 +v -8.199769 -6.547227 -0.044602 +v -4.195515 -5.997615 -0.590282 +v 7.674257 -5.872370 -1.270953 +v 7.818276 -6.015651 -0.297058 +v 11.799412 -6.650712 -0.593172 +v -8.199703 -6.009687 -0.459218 +v -6.831578 -5.986816 -0.775560 +v -5.176999 -5.998647 -0.699936 +v 8.704158 -5.990420 -0.735459 +v 10.941131 -5.997840 -0.631741 +v 11.799377 -5.963696 -0.834179 +v -8.199658 6.020744 -0.310751 +v -8.199599 6.552494 -1.177571 +v -6.829805 5.970607 -0.831946 +v -4.985057 5.903795 -1.184989 +v -4.190019 5.985622 -0.621282 +v 7.630058 6.594994 -1.480723 +v 7.769473 5.964656 -0.740573 +v 8.809499 6.020234 -0.452149 +v 11.001914 5.991692 -0.632089 +v 11.799571 5.950428 -0.899059 +v 11.799513 6.586768 -0.676583 +v -8.199570 7.696561 -0.663149 +v -4.192334 8.453691 -0.661321 +v 7.649990 8.488600 -1.404368 +v 7.801488 7.392091 -0.467919 +v 11.799460 7.596734 -0.703268 +v -8.199554 9.996956 -0.059296 +v -4.208280 9.999487 -0.457902 +v 7.632094 9.999632 -1.440138 +v 7.824550 9.999273 -0.314720 +v 11.799555 8.812249 -0.723596 +v -8.197688 9.999276 -0.661298 +v -6.633120 9.999596 -0.731441 +v -5.208707 9.999684 -0.783758 +v 8.773975 9.999633 -0.861566 +v 10.802381 9.999455 -0.713570 +v 11.799714 9.999182 -0.785225 +v -8.197686 -9.999451 1.010939 +v -8.199541 -9.997275 0.260243 +v -6.615919 -9.999615 0.589153 +v -5.262418 -9.999700 -0.007006 +v -4.209271 -9.999540 0.433489 +v 8.779774 -9.999577 1.415871 +v 7.824505 -9.999371 0.331457 +v 10.742769 -9.999483 0.797123 +v 11.799760 -9.999220 0.212846 +v 11.799611 -8.815681 0.536668 +v -8.199557 -7.696405 0.725159 +v -4.193613 -8.468247 0.649148 +v 7.798675 -7.350070 0.498136 +v 11.799520 -7.637108 0.626647 +v -8.199504 -6.481462 1.294399 +v -4.199493 -5.996171 0.544490 +v 7.760544 -5.957045 0.805830 +v 11.799439 -6.607526 0.605803 +v -8.199629 -5.957602 0.895889 +v -6.777077 -6.005857 0.596030 +v -5.031775 -5.996729 0.636892 +v 8.938672 -5.986028 0.794650 +v 10.848825 -5.997306 0.635572 +v 11.799419 -6.008822 0.373658 +v -8.200001 5.933025 1.035385 +v -8.199828 6.552780 0.180893 +v -6.764019 6.001985 0.588188 +v -5.129140 6.026583 0.126953 +v -4.200074 6.001789 0.516684 +v 8.849153 5.925123 1.118087 +v 7.812254 6.013496 0.354384 +v 10.911695 5.988643 0.664857 +v 11.799494 6.011581 0.171386 +v 11.799451 6.576842 0.497613 +v -8.199492 7.685225 0.709118 +v -4.198419 8.757403 0.554094 +v 7.784419 8.616837 0.641178 +v 11.799432 7.609749 0.578961 +v -8.199509 9.996929 1.321673 +v -4.164239 9.999508 0.836725 +v 7.746129 9.999648 0.873186 +v 11.799561 8.808537 0.648856 +v -8.197680 9.999266 0.730803 +v -6.542542 9.999572 0.734784 +v -5.273170 9.999640 0.387865 +v 8.985755 9.999613 1.158257 +v 10.688242 9.999451 0.658293 +v 11.799711 9.999186 0.598196 +v -8.197648 -9.999448 2.395411 +v -8.199549 -9.997281 1.640028 +v -6.605830 -9.999605 2.045255 +v -4.876506 -9.999592 1.610004 +v -3.920527 -9.998597 1.946740 +v 7.626151 -9.999424 1.463730 +v 7.832772 -9.999577 2.421417 +v 7.411798 -9.999217 2.153311 +v 9.377962 -9.999535 2.682787 +v 10.740405 -9.999465 2.167935 +v 11.799745 -9.999239 1.599765 +v 11.799598 -8.813943 1.913549 +v -8.199590 -7.683833 2.085014 +v -3.964387 -7.981873 1.762923 +v 7.643512 -8.503314 1.425363 +v 7.356836 -7.937525 2.302709 +v 11.799526 -7.607205 1.969600 +v -8.199491 -6.327385 2.585447 +v -4.001865 -5.805374 1.600292 +v 7.625906 -6.541778 1.489108 +v 7.343409 -6.082851 2.326025 +v 11.799542 -6.621174 1.995070 +v -8.199359 -5.638630 2.111626 +v -6.985033 -5.734489 1.856313 +v -3.880680 -5.704399 1.957182 +v 7.530046 -5.749290 1.817499 +v 9.581915 -5.606774 2.200391 +v 11.798736 -5.704845 1.942552 +v 11.799788 -5.870092 1.271592 +v -8.199745 5.649374 2.050942 +v -8.199661 6.474492 1.546607 +v -7.044656 5.711822 1.918720 +v -4.950350 5.807649 1.648982 +v -3.988319 5.772532 1.692573 +v 7.660441 5.858665 1.332667 +v 7.433918 5.641847 2.093051 +v 7.462678 6.582858 2.009177 +v 9.206911 5.572658 2.257581 +v 11.798150 5.702778 1.949545 +v 11.799784 5.911854 1.076341 +v 11.799452 6.649951 1.729318 +v -8.199503 7.682948 2.117119 +v -3.983454 8.864017 1.676720 +v 7.648629 7.220486 1.397030 +v 7.356742 7.947940 2.301305 +v 11.799465 7.579891 1.948669 +v -8.199507 9.997415 2.704021 +v -3.876131 9.999337 1.996297 +v 7.588977 9.998880 1.628080 +v 7.244533 9.999221 2.553261 +v 11.799548 8.805694 2.031880 +v -8.197663 9.999352 2.115082 +v -6.666515 9.999545 2.026457 +v -4.659828 9.999501 2.286154 +v 7.997352 9.999605 2.050205 +v 9.524428 9.999669 2.505622 +v 10.758471 9.999419 2.153772 +v 11.799698 9.999148 1.989041 +v -8.197604 -9.999436 3.777625 +v -8.199542 -9.997276 3.018459 +v -6.613389 -9.999603 3.488493 +v -4.903197 -9.999599 3.343227 +v -3.484757 -9.032300 2.883624 +v -3.232062 -9.999564 3.306391 +v -2.898742 -9.403237 3.752528 +v 7.514289 -9.999701 3.862231 +v 6.952609 -9.999518 3.119586 +v 9.228271 -9.999551 3.612877 +v 10.791119 -9.999423 3.447059 +v 11.799726 -9.999217 2.977890 +v 11.799569 -8.813658 3.304755 +v -8.199584 -7.670146 3.460722 +v -3.574334 -7.421838 2.720092 +v -2.955174 -8.181083 3.689918 +v 6.929611 -7.282344 3.145288 +v 11.799459 -7.601341 3.513390 +v -8.199472 -6.097076 4.004302 +v -3.668883 -6.094775 2.507122 +v -3.106965 -6.651191 3.490491 +v 6.989048 -5.820842 3.030916 +v 11.799523 -6.413495 3.838398 +v -8.199566 -5.202332 3.007745 +v -7.310356 -5.254818 2.941412 +v -4.878685 -5.253971 2.941320 +v -3.437903 -5.216196 2.984052 +v 7.142684 -5.352290 2.759473 +v 9.171059 -5.224774 2.997767 +v 11.799118 -5.143877 3.134670 +v 11.799718 -5.521446 3.394627 +v -8.199678 5.163284 3.076580 +v -8.199640 6.266432 3.062677 +v -8.197410 5.233962 2.990004 +v -5.655044 5.262937 2.932223 +v -3.589515 6.744640 2.681872 +v -3.526234 5.344194 2.796168 +v -3.123183 6.025649 3.453053 +v 7.115854 5.316240 2.797781 +v 7.069099 6.633917 2.914916 +v 8.659121 5.242633 2.947301 +v 10.493149 5.202950 3.027650 +v 11.799786 5.280582 2.874469 +v 11.799526 6.204838 3.562408 +v -8.199533 7.669547 3.572965 +v -3.572335 8.836848 2.712472 +v -3.035518 7.339932 3.584669 +v 6.870486 8.661427 3.243575 +v 11.799454 7.538053 3.402397 +v -8.199501 9.997368 4.086070 +v -3.441025 9.999057 2.948609 +v -3.043382 9.046356 3.571433 +v 6.829948 9.999537 3.286023 +v 11.799528 8.805180 3.408148 +v -8.197643 9.999428 3.486793 +v -6.608270 9.999547 3.379310 +v -4.656811 9.999462 3.515515 +v -2.852458 9.999164 3.816640 +v 7.679753 9.999552 3.556726 +v 9.301382 9.999568 3.488949 +v 10.795737 9.999445 3.493431 +v 11.799670 9.999133 3.364438 +v -8.197533 -9.999407 5.158651 +v -8.199509 -9.997257 4.397439 +v -6.614145 -9.999590 4.871537 +v -4.890576 -9.999644 4.716255 +v -3.387088 -9.999677 4.570394 +v -2.261416 -8.855969 4.442127 +v -2.437099 -9.999797 4.273759 +v -1.475395 -9.998314 5.060349 +v 6.314816 -9.999750 3.969246 +v 6.372498 -9.999758 5.163692 +v 5.514348 -9.999109 4.746866 +v 7.894446 -9.999682 5.250923 +v 9.104705 -9.999614 4.976558 +v 10.778880 -9.999447 4.779432 +v 11.799697 -9.999177 4.349587 +v 11.799519 -8.811727 4.694307 +v -8.199552 -7.677637 4.819081 +v -2.326875 -7.348844 4.383356 +v -1.414021 -8.229893 5.094482 +v 6.304777 -8.513800 3.997373 +v 5.519537 -7.706742 4.738986 +v 11.799383 -7.601138 4.959494 +v -8.199544 -6.518438 5.266372 +v -2.592307 -5.674323 4.129151 +v -1.572373 -6.586298 4.992676 +v 6.379261 -6.271595 3.913774 +v 5.564940 -5.660277 4.694994 +v 11.799389 -6.610602 5.180979 +v -8.199607 -4.633092 3.829645 +v -8.199579 -4.940305 5.222962 +v -8.198113 -4.658551 3.816161 +v -5.562227 -4.641238 3.832510 +v -2.897785 -4.716269 3.746663 +v -2.415937 -4.210419 4.282786 +v -1.687272 -5.075503 4.909489 +v 6.191103 -4.383311 4.104564 +v 5.777611 -3.965346 4.504145 +v 6.656023 -4.862808 3.557405 +v 8.718608 -4.682957 3.789617 +v 10.767363 -4.562404 3.922218 +v 11.799873 -4.548215 3.924178 +v 11.799562 -5.320532 5.055294 +v -8.199165 -3.881455 4.612430 +v -6.509099 -3.935783 4.554987 +v -4.377144 -3.943481 4.548967 +v -2.163820 -3.983776 4.510769 +v -1.936068 -3.714067 4.715118 +v 5.914590 -4.138125 4.370803 +v 8.125601 -3.986704 4.517064 +v 10.043089 -3.834943 4.643246 +v 11.799370 -3.964401 4.528506 +v 11.799733 -4.273866 5.016637 +v -8.199439 4.553471 3.948913 +v -8.199603 3.820593 4.636240 +v -8.199636 4.944487 4.649948 +v -6.525842 4.589891 3.898226 +v -8.198012 3.793169 4.675235 +v -4.569866 4.691994 3.773846 +v -5.742564 3.892035 4.593493 +v -2.888156 4.688345 3.772836 +v -3.804736 3.994417 4.504154 +v -2.265120 4.988791 4.426857 +v -2.240862 4.052150 4.446306 +v -1.783468 4.621441 4.826989 +v 6.324891 4.535066 3.956394 +v 5.781214 3.975436 4.501049 +v 5.694842 5.037789 4.596434 +v 7.607679 4.786399 3.656248 +v 6.934111 4.000844 4.495538 +v 9.714689 4.656276 3.814215 +v 8.652557 3.995179 4.507631 +v 11.799059 4.635889 3.852334 +v 10.731492 3.947613 4.539780 +v 11.799675 4.923650 4.178159 +v 11.799873 3.935280 4.538691 +v 11.799614 4.736063 5.045347 +v -8.199549 6.251171 4.807276 +v -2.413476 6.279981 4.301875 +v -1.572040 5.738152 4.986212 +v 6.585310 4.772292 3.674067 +v 5.582396 6.822455 4.694520 +v 11.799458 6.217318 4.913799 +v -8.199501 7.659194 5.002742 +v -2.355846 8.124399 4.355531 +v -1.519149 7.398329 5.026831 +v 6.312459 7.750959 3.994457 +v 5.399946 8.697538 4.829699 +v 11.799453 7.525975 4.752891 +v -8.199476 9.997221 5.467452 +v -2.407282 9.595368 4.296461 +v -1.555586 9.016800 5.002069 +v 6.196377 9.999150 4.122355 +v 5.359331 9.999829 4.844940 +v 11.799500 8.803800 4.783926 +v -8.197597 9.999513 4.869787 +v -6.603934 9.999537 4.755031 +v -4.828739 9.999626 4.711396 +v -3.150458 9.999444 4.755021 +v -1.955161 9.999261 4.709900 +v 6.579113 9.999763 4.931122 +v 8.032317 9.999701 5.081255 +v 9.130602 9.999653 4.918978 +v 10.772133 9.999453 4.835412 +v 11.799621 9.999120 4.740206 +v -8.198836 -9.999576 6.599982 +v -8.199536 -9.997142 5.790784 +v -6.593763 -9.999537 6.273440 +v -4.891569 -9.999576 6.165531 +v -3.407455 -9.999640 6.159891 +v -2.140768 -9.999674 6.057826 +v -0.253161 -9.996292 5.681166 +v -0.732826 -9.999672 5.443184 +v 1.168884 -9.999240 5.995071 +v 0.893293 -9.999910 5.943188 +v 2.445173 -9.998594 5.992521 +v 2.018133 -9.999987 6.001723 +v 3.710248 -9.999373 5.709534 +v 3.452814 -9.999612 6.443748 +v 4.602591 -9.999867 5.316617 +v 5.026127 -9.999751 6.284465 +v 6.527148 -9.999660 6.639332 +v 7.692792 -9.999639 6.365069 +v 9.155256 -9.999598 6.332682 +v 10.780894 -9.999430 6.153181 +v 11.799646 -9.999138 5.728943 +v 11.799455 -8.807916 6.074277 +v -8.199540 -7.701340 6.132294 +v -0.465143 -7.326340 5.585181 +v 0.806051 -7.705533 5.947732 +v 2.167661 -7.864732 6.018025 +v 3.433831 -8.227327 5.801888 +v 4.556376 -8.772090 5.355238 +v 11.799363 -7.562963 6.270380 +v -8.199543 -6.317929 6.325528 +v -0.569042 -5.741171 5.545783 +v 0.715764 -6.124307 5.935107 +v 2.085078 -6.265229 6.028141 +v 3.470301 -6.420700 5.801060 +v 4.564419 -6.928053 5.354861 +v 11.799391 -6.329367 6.303913 +v -8.199546 -5.187172 6.618011 +v -0.773766 -4.194862 5.462619 +v 0.651937 -4.668273 5.928223 +v 2.091592 -4.790364 6.030248 +v 3.507766 -4.776062 5.794158 +v 4.796176 -4.906463 5.236584 +v 11.799401 -5.285198 6.519322 +v -8.199609 -2.849556 5.297946 +v -8.199624 -3.664600 6.327331 +v -7.251609 -3.079662 5.171209 +v -4.840324 -3.046456 5.196449 +v -3.173756 -3.090742 5.169651 +v -1.333320 -3.167730 5.128797 +v -0.438994 -2.975902 5.591105 +v 0.667161 -3.273909 5.930734 +v 2.098407 -3.376037 6.030735 +v 3.477165 -3.369145 5.797413 +v 4.670855 -2.839583 5.295374 +v 5.183542 -3.422887 4.963670 +v 7.854371 -3.120899 5.156997 +v 9.480741 -2.963974 5.247348 +v 11.798720 -2.907257 5.284715 +v 11.799572 -3.233733 5.598043 +v 11.799516 -4.090414 6.263210 +v -8.199569 -1.777986 5.752754 +v -8.199684 -2.073697 6.565345 +v -7.264945 -2.072580 5.655783 +v -4.892786 -1.973478 5.698500 +v -3.397542 -1.971724 5.698974 +v -1.919820 -2.045193 5.674397 +v -0.264450 -2.066415 5.661018 +v 0.684231 -2.010216 5.931263 +v 2.083226 -2.029805 6.030014 +v 3.356159 -1.497632 5.818394 +v 3.826452 -2.049183 5.665979 +v 6.057512 -2.160626 5.639706 +v 7.597582 -2.099295 5.663253 +v 9.218068 -1.914662 5.719605 +v 11.075790 -1.797488 5.752544 +v 11.799682 -1.879533 5.710035 +v 11.799459 -2.611259 6.542984 +v -8.199503 -0.491903 6.007307 +v -8.199680 -0.705138 6.566795 +v -6.826282 -0.832144 5.976810 +v -4.986693 -0.758232 5.991442 +v -3.454064 -0.674392 5.996832 +v -2.017308 -0.693402 5.996998 +v -0.659782 -0.731215 5.994454 +v 0.981827 -0.639725 5.987810 +v 1.873149 -0.349767 6.018599 +v 2.461390 -0.602868 5.989574 +v 4.776151 -0.726427 5.991949 +v 6.136178 -0.749839 5.992536 +v 7.583019 -0.730423 5.993953 +v 9.158060 -0.643490 6.002358 +v 10.940804 -0.600352 5.999825 +v 11.799425 -0.848953 5.961709 +v 11.799377 -1.265357 6.655302 +v -8.199269 0.869105 5.962118 +v -8.199540 0.631636 6.536277 +v -6.759963 0.557422 6.009027 +v -4.964341 0.624918 6.007119 +v -3.428904 0.722607 5.994528 +v -2.003873 0.735437 5.993473 +v -0.644371 0.707168 5.995105 +v 1.269206 0.556508 5.995347 +v 2.153611 0.594159 5.999916 +v 3.452286 0.744381 5.994117 +v 4.780762 0.707640 5.998236 +v 6.183371 0.673867 5.998772 +v 7.648952 0.686417 5.996594 +v 9.206982 0.702172 5.994337 +v 10.908156 0.670501 5.988912 +v 11.799513 0.354212 6.009020 +v 11.799365 0.022660 6.588048 +v -8.199455 2.091788 5.646234 +v -8.199589 2.000721 6.361542 +v -6.981493 1.869726 5.731795 +v -4.996750 1.946730 5.711601 +v -3.401004 2.079662 5.668446 +v -1.987114 2.107888 5.656106 +v -0.118843 1.966891 5.693007 +v 0.741546 1.063469 5.928512 +v 2.095185 2.057822 6.031780 +v 3.456326 1.679935 5.791945 +v 4.656799 2.079864 5.661766 +v 6.081037 2.044723 5.677777 +v 7.585537 1.976333 5.697745 +v 9.258666 2.020109 5.684668 +v 11.799003 1.903737 5.716467 +v 11.799769 1.238652 5.876719 +v 11.799578 1.322360 6.558140 +v -8.199514 2.990314 5.212738 +v -8.199485 3.491012 6.027864 +v -7.336644 2.954827 5.248124 +v -5.272383 3.020040 5.215442 +v -3.525569 3.152794 5.135769 +v -1.510501 3.319746 5.026337 +v -0.666315 2.442990 5.499047 +v 0.644604 3.381651 5.924020 +v 2.057189 3.366446 6.033311 +v 3.485343 3.235444 5.796387 +v 4.504560 2.662781 5.382405 +v 5.050210 3.268426 5.061302 +v 7.345608 3.085526 5.173554 +v 9.039054 3.076751 5.178569 +v 11.799359 3.113237 5.160700 +v 11.799804 3.108680 5.573142 +v 11.799582 2.963363 6.427597 +v -8.199545 4.871060 6.191875 +v -0.726174 4.991884 5.482443 +v 0.627673 4.824507 5.924534 +v 2.046442 4.808081 6.031816 +v 3.469420 4.650023 5.802474 +v 4.831454 4.137271 5.218531 +v 11.799453 4.831713 6.259270 +v -8.199493 6.209351 6.230690 +v -0.526029 6.782165 5.560700 +v 0.658040 6.393522 5.926639 +v 2.061201 6.358305 6.030103 +v 3.382344 6.218768 5.820481 +v 4.600585 5.819009 5.338509 +v 11.799470 6.223872 6.213105 +v -8.199493 7.644015 6.393284 +v -0.508467 8.557963 5.564147 +v 0.659633 8.134601 5.918595 +v 1.972727 8.050250 6.028858 +v 3.331390 8.060669 5.831500 +v 4.510781 7.713500 5.379684 +v 11.799459 7.548244 6.118355 +v -8.199451 9.997745 6.856752 +v -0.844982 9.998706 5.412596 +v 0.430627 9.998777 5.869935 +v 1.678644 9.998960 6.026149 +v 2.947410 9.998911 5.917114 +v 4.347351 9.999228 5.467326 +v 11.799460 8.816775 6.153218 +v -8.197533 9.999701 6.268875 +v -6.607411 9.999584 6.158972 +v -4.915001 9.999562 6.138621 +v -3.383697 9.999627 6.176419 +v -2.011267 9.999591 6.131787 +v -0.351281 9.999445 6.123900 +v 1.223312 9.999739 5.973482 +v 2.379461 9.999793 5.972810 +v 3.753112 9.999563 6.374414 +v 5.314850 9.999664 6.072073 +v 6.652303 9.999625 6.451530 +v 7.715760 9.999647 6.286867 +v 9.132211 9.999601 6.316644 +v 10.763255 9.999510 6.223470 +v 11.799530 9.999296 6.123329 +v -8.198895 -9.999526 8.006126 +v -8.199519 -9.192599 7.175292 +v -6.417950 -9.999429 7.756643 +v -4.815599 -9.999453 7.633683 +v -3.368346 -9.999523 7.684534 +v -2.000195 -9.999560 7.687109 +v -0.651669 -9.999557 7.686626 +v 0.729027 -9.999627 7.627478 +v 2.094055 -9.999655 7.697778 +v 3.410515 -9.999652 7.762918 +v 4.816259 -9.999615 7.719515 +v 6.363036 -9.999561 7.719858 +v 7.744698 -9.999474 7.763176 +v 9.226645 -9.999427 7.762900 +v 10.766292 -9.999480 7.554846 +v 11.799546 -9.999265 7.098374 +v 11.799364 -8.772797 7.439370 +v -8.199441 -7.722961 7.545415 +v 11.799382 -7.433131 7.563033 +v -8.199511 -6.311924 7.660977 +v 11.799376 -6.120613 7.570129 +v -8.199534 -4.980803 7.686372 +v 11.799411 -4.844180 7.568948 +v -8.199574 -3.520487 7.683812 +v 11.799455 -3.479200 7.604340 +v -8.199579 -2.040208 7.697154 +v 11.799455 -2.102558 7.648109 +v -8.199542 -0.651625 7.692732 +v 11.799451 -0.746140 7.619711 +v -8.199515 0.718359 7.687811 +v 11.799507 0.617562 7.602089 +v -8.199542 2.063252 7.668056 +v 11.799526 2.025604 7.617967 +v -8.199553 3.418680 7.652824 +v 11.799480 3.516902 7.571071 +v -8.199521 4.779530 7.644626 +v 11.799485 4.961886 7.544385 +v -8.199498 6.158218 7.669830 +v 11.799493 6.338737 7.540397 +v -8.199495 7.630288 7.840914 +v 11.799438 7.662631 7.459908 +v -8.199335 9.016942 8.308546 +v 11.799427 8.887952 7.486588 +v -8.198661 9.999797 7.692573 +v -6.609943 9.999473 7.675223 +v -5.050881 9.999443 7.642745 +v -3.590057 9.999554 7.715032 +v -2.193910 9.999576 7.722970 +v -0.766948 9.999570 7.703002 +v 0.704516 9.999436 7.683696 +v 2.062999 9.999517 7.713124 +v 3.369528 9.999482 7.718036 +v 4.775780 9.999557 7.701522 +v 6.202618 9.999552 7.708895 +v 7.517828 9.999548 7.762272 +v 8.951915 9.999498 7.802186 +v 10.592942 9.999502 7.731933 +v 11.799470 9.999449 7.539344 +v -8.198413 -9.999622 9.998239 +v -8.199584 -9.997097 8.707922 +v -6.213819 -9.999378 9.997805 +v -4.750348 -9.999394 9.997395 +v -3.315425 -9.999398 9.997358 +v -1.930486 -9.999413 9.997904 +v -0.552704 -9.999448 9.997867 +v 0.825830 -9.999471 9.997808 +v 2.205785 -9.999476 9.997803 +v 3.581178 -9.999465 9.997853 +v 4.964279 -9.999454 9.997849 +v 6.355896 -9.999468 9.997790 +v 7.745800 -9.999449 9.997847 +v 9.219168 -9.999370 9.997507 +v 10.843001 -9.999401 9.998410 +v 11.799453 -9.999250 8.419680 +v 11.799330 -8.519844 8.719084 +v -8.199432 -7.614718 9.009619 +v 11.799362 -7.090093 8.787507 +v -8.199415 -6.347914 9.996894 +v 11.799490 -5.723805 8.804754 +v -8.199486 -4.960229 9.997334 +v 11.799552 -4.354128 8.811058 +v -8.199503 -3.580727 9.997179 +v 11.799592 -2.975622 8.817688 +v -8.199525 -2.189095 9.996919 +v 11.799616 -1.596662 8.818361 +v -8.199529 -0.807254 9.997140 +v 11.799514 -0.218284 8.818473 +v -8.199525 0.566889 9.997272 +v 11.799629 1.164615 8.819294 +v -8.199523 1.950375 9.997380 +v 11.799609 2.553452 8.815332 +v -8.199507 3.328820 9.997098 +v 11.799586 3.942916 8.809958 +v -8.199467 4.705613 9.997397 +v 11.799554 5.326713 8.805850 +v -8.199488 6.104328 9.997167 +v 11.799493 6.694594 8.800132 +v -8.199504 7.567066 9.998184 +v 11.799426 7.989631 8.709000 +v -8.199445 8.779883 9.998020 +v 11.799459 8.997715 8.581887 +v -8.199387 9.999408 8.970480 +v -6.777565 9.999531 9.998397 +v -5.365391 9.999403 9.997413 +v -3.927644 9.999436 9.997842 +v -2.536396 9.999489 9.997868 +v -1.153995 9.999486 9.997896 +v 0.234385 9.999497 9.997862 +v 1.620074 9.999511 9.997829 +v 2.996753 9.999506 9.997827 +v 4.375471 9.999478 9.997868 +v 5.757544 9.999440 9.997920 +v 7.132275 9.999399 9.997419 +v 8.527854 9.999317 9.997542 +v 10.039479 9.999365 9.997566 +v 11.799401 9.999590 9.997819 +v -8.199564 -8.624424 9.999681 +v -6.482371 -9.997217 9.999541 +v -5.009321 -9.997786 9.999495 +v -3.630431 -9.997612 9.999303 +v -2.297617 -9.997481 9.999337 +v -0.940568 -9.997551 9.999459 +v 0.457845 -9.997609 9.999485 +v 1.841860 -9.997621 9.999490 +v 3.231818 -9.997558 9.999452 +v 4.660732 -9.997554 9.999393 +v 6.066957 -9.997600 9.999438 +v 7.458948 -9.997618 9.999593 +v 8.955096 -9.997232 9.999422 +v 10.518956 -9.997651 9.999676 +v 11.799704 -9.998227 10.000151 +v -8.198829 -7.149347 9.999371 +v -6.551334 -7.616679 9.999355 +v -5.045575 -7.794369 9.999452 +v -3.682493 -7.796916 9.999565 +v -2.651813 -8.004390 9.999441 +v -1.378949 -7.670482 9.999584 +v 0.122412 -8.052332 9.999581 +v 1.507608 -8.146821 9.999683 +v 2.823739 -8.121555 9.999640 +v 4.427471 -7.765769 9.999485 +v 6.067692 -7.768857 9.999388 +v 7.508152 -7.692230 9.999501 +v 9.000263 -7.626652 9.999393 +v 10.605927 -7.816845 9.999273 +v 11.799420 -8.022960 9.999205 +v -8.197575 -5.749109 9.999455 +v -6.643966 -6.198463 9.999369 +v -5.056807 -6.328191 9.999640 +v -3.930152 -6.506070 9.999598 +v -2.585245 -6.364953 9.999727 +v -1.460860 -6.202265 9.999833 +v -0.357494 -6.693348 9.999821 +v 1.138199 -6.990582 9.999727 +v 2.235683 -6.994594 9.999871 +v 3.593463 -6.768392 9.999779 +v 4.751307 -6.798151 9.999775 +v 6.025942 -6.443050 9.999696 +v 5.528597 -5.939122 9.999930 +v 7.558318 -6.300421 9.999571 +v 9.092954 -6.171248 9.999442 +v 10.767450 -6.283085 9.999371 +v 11.799585 -6.599038 9.999393 +v -8.197687 -4.363800 9.999595 +v -6.697226 -4.857450 9.999515 +v -5.376136 -5.217707 9.999482 +v -3.866692 -4.970774 9.999804 +v -2.965106 -5.140057 10.000067 +v -2.223149 -5.747599 10.000653 +v 6.219190 -5.438278 9.999787 +v 7.498934 -5.093988 9.999743 +v 6.860356 -4.856116 10.000163 +v 9.124454 -4.846385 9.999537 +v 10.780791 -4.890007 9.999356 +v 11.799676 -5.216230 9.999317 +v -8.197745 -3.046002 9.999527 +v -6.892328 -3.718954 9.999606 +v -5.276845 -3.657884 9.999616 +v -4.180528 -3.647812 10.000177 +v -3.662360 -4.407913 10.000999 +v 7.746449 -4.151927 10.000130 +v 9.069589 -3.501289 9.999720 +v 8.096116 -3.080591 10.000010 +v 10.784621 -3.539178 9.999447 +v 11.799721 -3.836383 9.999422 +v -8.197820 -1.599533 9.999390 +v -6.565421 -2.334403 9.999640 +v -5.346675 -2.324520 9.999730 +v -4.556663 -2.960433 10.000019 +v 9.389369 -1.907399 9.999751 +v 8.491092 -2.123599 9.999962 +v 10.775268 -2.164165 9.999501 +v 11.799750 -2.455609 9.999463 +v -8.197861 -0.247850 9.999347 +v -6.811171 -0.788280 9.999574 +v -5.667758 -1.283189 9.999701 +v 9.426335 -0.674212 9.999802 +v 8.770505 -0.854926 10.000260 +v 10.819429 -0.812561 9.999546 +v 11.799530 -1.076964 9.999483 +v -8.197721 1.113538 9.999526 +v -6.695457 0.706579 9.999656 +v -5.198022 0.223380 9.999601 +v 9.478483 0.755854 9.999822 +v 8.804891 0.498223 10.000130 +v 10.802117 0.521933 9.999569 +v 11.799535 0.299132 9.999496 +v -8.197616 2.553666 9.999619 +v -6.393997 2.191061 9.999769 +v -5.000073 1.690724 10.000030 +v 9.444489 2.119722 9.999681 +v 8.584241 1.806372 9.999890 +v 10.801788 1.891360 9.999513 +v 11.799761 1.679014 9.999472 +v -8.197587 3.914190 9.999598 +v -6.641249 3.536174 9.999636 +v -4.655480 2.713439 10.000096 +v -4.657337 3.752016 10.000007 +v -4.307789 3.458856 10.000555 +v 9.188093 3.669265 9.999661 +v 8.154366 2.976876 9.999822 +v 10.794128 3.321449 9.999415 +v 11.799740 3.061862 9.999424 +v -8.197502 5.291067 9.999585 +v -6.616482 4.885984 9.999526 +v -4.725832 4.918136 9.999666 +v -3.679889 4.376944 10.000923 +v -3.099369 5.011426 10.000212 +v -3.064500 5.058109 10.613419 +v 8.030270 5.100888 9.999699 +v 6.850599 4.858488 9.999699 +v 7.510542 4.084056 10.000174 +v 9.593278 5.261938 9.999496 +v 10.780684 4.822471 9.999332 +v 11.799705 4.447821 9.999357 +v -8.197726 6.714377 9.999689 +v -6.594540 6.283097 9.999458 +v -4.882166 6.177976 9.999474 +v -3.349746 6.217818 9.999723 +v -2.410607 5.608188 10.000583 +v -2.016270 6.351987 10.000078 +v -1.431322 6.233377 10.001153 +v 6.741755 6.431904 9.999672 +v 5.665489 6.333992 9.999810 +v 6.222313 5.441659 9.999949 +v 8.098748 6.600520 9.999571 +v 9.288901 6.398204 9.999512 +v 10.805679 6.209039 9.999350 +v 11.799641 5.828120 9.999256 +v -8.197885 8.074722 9.999633 +v -6.428494 7.779856 9.999462 +v -4.823626 7.636750 9.999390 +v -3.368710 7.697879 9.999340 +v -1.972622 7.782469 9.999458 +v -0.149931 6.745010 10.000200 +v -0.092688 7.790108 9.999634 +v 1.114905 6.985478 9.999789 +v 1.470623 8.122133 9.999679 +v 2.146079 6.999486 9.999908 +v 2.783982 8.133174 9.999678 +v 3.373640 6.824813 9.999860 +v 4.075569 8.034867 9.999547 +v 4.595573 6.421569 9.999683 +v 5.526074 7.681545 9.999496 +v 6.786095 8.085253 9.999398 +v 7.832828 7.832361 9.999531 +v 9.238482 7.831200 9.999429 +v 10.784788 7.631334 9.999335 +v 11.799516 7.217441 9.999315 +v -8.197994 9.998039 9.999844 +v -6.316532 9.997849 9.999547 +v -4.802325 9.997334 9.999498 +v -3.356526 9.997637 9.999380 +v -1.969724 9.997608 9.999352 +v -0.555346 9.997558 9.999425 +v 0.885156 9.997589 9.999476 +v 2.274942 9.997643 9.999504 +v 3.647022 9.997624 9.999489 +v 5.030220 9.997557 9.999452 +v 6.392834 9.997459 9.999316 +v 7.729717 9.997419 9.999293 +v 9.153417 9.997105 9.999487 +v 10.741776 9.996381 9.999431 +v 11.799560 8.470680 9.999248 +v -0.404709 -6.664995 11.554741 +v -1.382784 -6.251769 10.795120 +v 0.758790 -6.947167 10.947076 +v 2.039844 -7.016795 10.698895 +v 3.220670 -6.881452 10.001741 +v 4.436515 -6.513659 10.000566 +v 5.375319 -6.037236 11.440392 +v -2.232946 -5.739280 11.858047 +v -2.974597 -5.142347 11.167279 +v 6.210507 -5.454947 10.788593 +v 6.937014 -4.779386 11.518373 +v -3.678247 -4.384391 11.881513 +v -4.227842 -3.585689 10.988430 +v 7.584970 -3.978674 10.001174 +v 8.138568 -3.016685 10.814351 +v -4.684201 -2.675569 11.642596 +v -4.935275 -1.960181 10.000401 +v 8.562464 -1.904815 11.151234 +v -5.203216 -0.619530 10.000870 +v 8.803132 -0.607090 11.372915 +v -5.190219 0.720567 10.001980 +v 8.786640 0.779945 11.332220 +v -4.999945 1.719525 11.342272 +v 8.502203 2.106539 11.078352 +v -4.722423 2.576716 10.002184 +v -4.316759 3.437123 11.722026 +v 8.020063 3.251772 11.025887 +v -3.754797 4.288280 11.125069 +v -3.038214 5.082627 11.927536 +v 6.854202 4.864918 10.777021 +v 7.466840 4.134807 11.576744 +v -2.259727 5.720581 11.106215 +v -1.422524 6.230896 11.805859 +v 5.346220 6.057312 10.000598 +v 6.118587 5.528689 11.459556 +v -0.474733 6.641531 11.076231 +v 0.727077 6.940412 10.731045 +v 1.983538 7.019841 10.670968 +v 3.138229 6.896154 10.001928 +v 4.286364 6.570463 10.001639 +v -0.386615 -6.670319 13.475606 +v -1.388303 -6.249818 12.549366 +v 0.774231 -6.950734 13.097659 +v 2.064777 -7.023451 12.924847 +v 3.283530 -6.866714 12.629443 +v 4.365408 -6.536121 12.098398 +v 5.356597 -6.047819 13.278268 +v -2.231516 -5.741513 13.418161 +v -3.003114 -5.113668 12.698648 +v 6.196295 -5.467237 12.424162 +v 6.916834 -4.800122 13.298300 +v -3.686411 -4.373683 13.432901 +v -4.257881 -3.540490 12.610509 +v 7.572799 -3.990224 12.247914 +v 8.111888 -3.074136 12.748497 +v -4.704855 -2.627928 13.334713 +v -5.019505 -1.655190 12.191307 +v 8.549565 -1.958790 12.952046 +v -5.205462 -0.505181 12.559058 +v 8.801131 -0.665640 13.034342 +v -5.193910 0.627844 12.985631 +v 8.794641 0.744803 12.996449 +v -5.017103 1.658659 13.363552 +v 8.515674 2.076982 13.051427 +v -4.707131 2.614586 12.464544 +v -4.287261 3.489819 13.393639 +v 8.055944 3.186260 13.169722 +v -3.729252 4.321498 12.677428 +v -3.040948 5.077468 13.439370 +v 6.846666 4.872763 12.415679 +v 7.500609 4.090317 13.478500 +v -2.273808 5.711595 12.666708 +v -1.418305 6.234737 13.542205 +v 5.255364 6.106658 12.051708 +v 6.113030 5.533993 13.270182 +v -0.423342 6.658939 13.146818 +v 0.738872 6.947048 13.005163 +v 2.036195 7.025925 12.920578 +v 3.261397 6.871166 12.773114 +v 4.294405 6.561888 12.483998 +v -0.374150 -6.674630 15.087572 +v -1.370976 -6.258703 14.150152 +v 0.794503 -6.954881 14.730463 +v 2.091165 -7.023341 14.509645 +v 3.357184 -6.849730 14.314513 +v 4.437776 -6.503430 13.938549 +v 5.361373 -6.043685 14.826402 +v -2.227391 -5.744702 14.897988 +v -3.000783 -5.115834 14.158653 +v 6.176470 -5.483632 14.115022 +v 6.908572 -4.808744 14.833733 +v -3.690112 -4.369470 14.888336 +v -4.262735 -3.532651 14.144856 +v 7.548069 -4.023251 13.954201 +v 8.087588 -3.120667 14.307747 +v -4.707644 -2.620190 14.834729 +v -5.022691 -1.642535 13.918309 +v 8.527472 -2.027699 14.485723 +v -5.198924 -0.568150 14.301660 +v 8.794381 -0.733092 14.563501 +v -5.197902 0.576914 14.606277 +v 8.803965 0.665841 14.637280 +v -5.020350 1.646544 14.990965 +v 8.524565 2.043013 14.667359 +v -4.714475 2.601211 14.127140 +v -4.284865 3.493964 14.866563 +v 8.060459 3.174640 14.743015 +v -3.719708 4.331664 14.156874 +v -3.039497 5.079156 14.894168 +v 6.861058 4.858750 14.133147 +v 7.510722 4.076589 15.059595 +v -2.277096 5.709506 14.174766 +v -1.407040 6.240535 15.058189 +v 5.301427 6.079387 13.935813 +v 6.132848 5.517341 14.832022 +v -0.408837 6.664481 14.742353 +v 0.779073 6.953539 14.599014 +v 2.083631 7.023739 14.500589 +v 3.347586 6.851555 14.431849 +v 4.413405 6.512699 14.294495 +v -0.366315 -6.675437 16.952600 +v -1.356122 -6.266800 15.764019 +v 0.815215 -6.957287 16.577135 +v 2.161530 -7.021439 16.301128 +v 3.385474 -6.841762 15.941924 +v 4.455472 -6.495527 15.447703 +v 5.380936 -6.033587 16.425529 +v -2.211912 -5.756092 16.725527 +v -3.007405 -5.109622 15.770016 +v 6.180608 -5.480015 15.632506 +v 6.906437 -4.808105 16.490269 +v -3.695539 -4.363213 16.583389 +v -4.269347 -3.521611 15.651614 +v 7.536598 -4.038703 15.443009 +v 8.065992 -3.164154 15.880507 +v -4.712896 -2.606183 16.396795 +v -5.017803 -1.657165 15.394910 +v 8.503810 -2.097330 16.303724 +v -5.196722 -0.593522 15.773882 +v 8.783051 -0.846449 16.580355 +v -5.203835 0.527139 16.116684 +v 8.806689 0.652656 16.737356 +v -5.031038 1.609452 16.585714 +v 8.511791 2.074951 16.702953 +v -4.717294 2.594346 15.620203 +v -4.295251 3.475438 16.517382 +v 8.051929 3.187948 16.610466 +v -3.722175 4.328541 15.714138 +v -3.021608 5.098919 16.712322 +v 6.863254 4.856207 15.684073 +v 7.500587 4.090698 16.817381 +v -2.257318 5.724251 15.757606 +v -1.354491 6.266243 16.891415 +v 5.333356 6.059585 15.417947 +v 6.135925 5.513280 16.483198 +v -0.426569 6.655771 16.392332 +v 0.784891 6.953658 16.395918 +v 2.146489 7.021384 16.306808 +v 3.389823 6.841252 16.052271 +v 4.449823 6.498085 15.758986 +v -0.582788 -6.595362 18.999664 +v -1.337664 -6.273612 17.618839 +v 0.530260 -6.905825 18.999544 +v 2.142637 -7.035214 18.998800 +v 3.483616 -6.820990 17.795616 +v 4.481755 -6.483364 17.184540 +v 5.391660 -6.023991 18.109457 +v -2.048834 -5.864153 18.999622 +v -2.968259 -5.151852 18.998568 +v 6.197755 -5.465113 17.394392 +v 6.867369 -4.855500 18.998432 +v -3.777458 -4.257582 18.999603 +v -4.283327 -3.501937 17.420820 +v 7.500039 -4.090722 17.229153 +v 8.042489 -3.205632 17.944044 +v -4.723695 -2.576720 18.998041 +v -5.011132 -1.673518 17.018755 +v 8.489552 -2.157534 18.999357 +v -5.185596 -0.700739 17.542685 +v 8.808784 -0.587110 18.999815 +v -5.207325 0.475031 17.873302 +v 8.757147 1.012802 18.999838 +v -5.030905 1.596845 18.131798 +v 8.410816 2.356683 18.999828 +v -4.728800 2.563359 17.297136 +v -4.339964 3.406822 18.999193 +v 7.969231 3.333843 18.999538 +v -3.731256 4.322196 18.997101 +v -3.022273 5.087537 18.999786 +v 6.865243 4.854503 17.475479 +v 7.480693 4.117693 18.998926 +v -2.198368 5.769955 18.996733 +v -1.316561 6.285483 18.999405 +v 5.368109 6.039005 17.140402 +v 6.153033 5.506114 18.998512 +v -0.501538 6.623068 18.432381 +v 0.510158 6.900224 18.999151 +v 2.037757 7.035807 18.998833 +v 3.438720 6.833452 18.997044 +v 4.472171 6.486749 17.630827 +v -0.419758 -6.162887 18.999804 +v -1.282530 -6.291184 19.000019 +v 0.562139 -6.360853 18.999802 +v 2.038842 -6.409124 18.999769 +v 3.582752 -6.784072 18.999821 +v 4.618444 -6.427100 18.999357 +v 5.360695 -6.032370 18.999912 +v -1.754393 -5.401208 18.999821 +v -2.672531 -4.862156 18.999655 +v 6.033245 -5.590606 18.999575 +v 6.715732 -4.704179 18.999634 +v -3.192754 -4.103057 18.999834 +v -4.343695 -3.376343 18.999968 +v 7.595253 -3.952276 18.999590 +v 8.052598 -3.162439 19.000080 +v -4.783033 -2.383818 18.999943 +v -5.007696 -1.697596 18.999117 +v 7.794069 -1.794174 18.999931 +v -5.203384 -0.477181 18.999594 +v 7.800010 -0.308560 18.999905 +v -5.176605 0.766331 18.999802 +v 7.797681 1.261689 18.999886 +v -5.004079 1.667275 18.999912 +v 7.815713 2.694906 18.999962 +v -4.797422 2.371113 18.999693 +v -3.994534 3.244930 18.999672 +v 7.790813 3.620349 18.999851 +v -3.886195 4.082253 18.999613 +v -2.646888 4.701065 18.999615 +v 6.876835 4.830838 18.999680 +v 7.265234 3.943586 18.999613 +v -2.059459 5.845382 18.999544 +v -1.151431 5.951427 18.999699 +v 5.214048 6.124995 18.999561 +v 5.965988 5.382691 18.999603 +v -0.673609 6.553061 18.999987 +v -0.084724 6.745022 18.999687 +v 1.398876 6.395272 18.999702 +v 3.084863 6.880538 18.999796 +v 4.412638 6.501444 18.999855 +v -0.678799 -5.391832 18.999899 +v 0.624825 -5.640241 18.999811 +v 2.052987 -5.707369 18.999916 +v 3.590884 -5.735614 18.999847 +v 4.758963 -5.866226 18.999826 +v -1.816533 -4.281603 18.999872 +v -0.374683 -4.300263 18.999992 +v 0.707510 -4.605871 18.999968 +v 2.069934 -4.703549 19.000027 +v 3.477571 -4.730026 19.000025 +v 4.746855 -4.898595 18.999897 +v 5.802374 -5.026480 18.999874 +v -3.359482 -2.825997 18.999943 +v -1.797490 -2.946874 19.000059 +v -0.588214 -3.283223 19.000071 +v 0.725950 -3.387789 19.000040 +v 2.073682 -3.430963 19.000071 +v 3.451158 -3.440566 19.000107 +v 4.804687 -3.475805 19.000051 +v 5.996051 -3.555539 18.999928 +v 6.891012 -3.772015 18.999899 +v -4.377805 -1.581656 18.999771 +v -3.165847 -1.570790 18.999832 +v -2.012611 -1.890440 18.999987 +v -0.652232 -2.008012 19.000082 +v 0.699707 -2.057180 19.000067 +v 2.070887 -2.067044 19.000055 +v 3.448277 -2.068965 19.000088 +v 4.821134 -2.092548 19.000111 +v 6.073223 -2.234985 19.000036 +v 7.088723 -2.562591 18.999964 +v -4.430764 -0.064294 18.999807 +v -3.347905 -0.511969 18.999792 +v -2.036382 -0.634434 18.999926 +v -0.682413 -0.676416 19.000036 +v 0.691577 -0.687734 19.000061 +v 2.068966 -0.689655 19.000048 +v 3.448277 -0.689655 19.000057 +v 4.821197 -0.713177 19.000078 +v 6.090087 -0.863216 19.000029 +v 7.053500 -1.236549 18.999943 +v -4.446630 1.270488 18.999842 +v -3.383532 0.891842 18.999809 +v -2.059218 0.718773 18.999933 +v -0.687734 0.691576 19.000017 +v 0.689656 0.689656 19.000044 +v 2.068966 0.689656 19.000032 +v 3.446356 0.687735 19.000015 +v 4.813130 0.664608 19.000019 +v 6.084222 0.526794 18.999983 +v 7.074152 0.216041 18.999884 +v -4.258647 2.340764 18.999874 +v -3.325603 2.157415 18.999838 +v -2.052379 2.092137 18.999941 +v -0.689655 2.068966 19.000042 +v 0.689656 2.068966 19.000063 +v 2.067045 2.067045 19.000021 +v 3.437917 2.056599 18.999952 +v 4.777792 2.010435 18.999905 +v 6.039190 1.921396 18.999910 +v 7.061870 1.631720 18.999866 +v -3.185593 3.481377 18.999651 +v -1.963875 3.433903 18.999916 +v -0.680453 3.440811 19.000031 +v 0.690856 3.442599 19.000092 +v 2.081156 3.435752 19.000036 +v 3.423676 3.391321 18.999916 +v 4.741650 3.290211 18.999826 +v 5.819085 3.001389 18.999819 +v 7.040553 3.181136 18.999777 +v -1.752769 4.904328 18.999651 +v -0.654389 4.739786 18.999931 +v 0.642986 4.715181 19.000040 +v 2.066998 4.729179 19.000032 +v 3.471437 4.671422 18.999910 +v 4.536838 4.367679 18.999815 +v 6.036970 4.302793 18.999722 +v -0.626406 5.825130 18.999796 +v 0.468965 5.713502 18.999750 +v 1.813095 5.665907 18.999962 +v 3.389557 5.721221 18.999929 +v 4.737714 5.529325 18.999819 +# 2132 vertices, 0 vertices normals + +f 1 2 3 +f 1 4 5 +f 2 1 5 +f 4 6 7 +f 5 4 7 +f 6 8 9 +f 7 6 9 +f 8 10 11 +f 9 8 11 +f 11 10 12 +f 13 14 15 +f 3 14 13 +f 3 13 1 +f 1 13 16 +f 4 1 17 +f 17 1 16 +f 6 4 18 +f 18 4 17 +f 8 6 19 +f 19 6 18 +f 10 8 20 +f 20 8 19 +f 21 12 10 +f 21 10 22 +f 22 10 20 +f 21 22 23 +f 24 25 26 +f 15 25 24 +f 15 24 13 +f 13 24 27 +f 16 13 28 +f 28 13 27 +f 17 16 29 +f 29 16 28 +f 18 17 30 +f 30 17 29 +f 19 18 31 +f 31 18 30 +f 20 19 32 +f 32 19 31 +f 22 20 33 +f 33 20 32 +f 34 23 22 +f 34 22 35 +f 35 22 33 +f 34 35 36 +f 37 38 39 +f 26 38 37 +f 26 37 24 +f 24 37 40 +f 27 24 41 +f 41 24 40 +f 28 27 42 +f 42 27 41 +f 29 28 43 +f 43 28 42 +f 30 29 44 +f 44 29 43 +f 31 30 45 +f 45 30 44 +f 32 31 46 +f 46 31 45 +f 33 32 47 +f 47 32 46 +f 35 33 48 +f 48 33 47 +f 49 36 35 +f 48 49 35 +f 50 37 39 +f 51 50 39 +f 40 37 52 +f 52 37 50 +f 41 40 53 +f 53 40 52 +f 42 41 54 +f 54 41 53 +f 43 42 55 +f 55 42 54 +f 44 43 56 +f 56 43 55 +f 45 44 57 +f 57 44 56 +f 46 45 58 +f 58 45 57 +f 47 46 59 +f 59 46 58 +f 48 47 60 +f 60 47 59 +f 61 49 48 +f 60 61 48 +f 62 50 51 +f 63 62 51 +f 52 50 64 +f 64 50 62 +f 53 52 65 +f 65 52 64 +f 54 53 66 +f 66 53 65 +f 55 54 67 +f 67 54 66 +f 56 55 68 +f 68 55 67 +f 57 56 69 +f 69 56 68 +f 58 57 70 +f 70 57 69 +f 59 58 71 +f 71 58 70 +f 60 59 72 +f 72 59 71 +f 73 61 60 +f 72 73 60 +f 74 62 63 +f 75 74 63 +f 64 62 76 +f 76 62 74 +f 65 64 77 +f 77 64 76 +f 66 65 78 +f 78 65 77 +f 67 66 79 +f 79 66 78 +f 68 67 80 +f 80 67 79 +f 69 68 81 +f 81 68 80 +f 70 69 82 +f 82 69 81 +f 71 70 83 +f 83 70 82 +f 72 71 84 +f 84 71 83 +f 85 73 72 +f 84 85 72 +f 74 75 86 +f 86 87 88 +f 86 88 74 +f 74 88 76 +f 77 76 89 +f 89 76 88 +f 78 77 90 +f 90 77 89 +f 79 78 91 +f 91 78 90 +f 80 79 92 +f 92 79 91 +f 81 80 93 +f 93 80 92 +f 82 81 94 +f 94 81 93 +f 83 82 95 +f 95 82 94 +f 84 83 96 +f 96 83 95 +f 97 85 84 +f 96 97 84 +f 88 87 98 +f 98 99 100 +f 98 100 88 +f 88 100 89 +f 90 89 101 +f 101 89 100 +f 91 90 102 +f 102 90 101 +f 92 91 103 +f 103 91 102 +f 93 92 104 +f 104 92 103 +f 94 93 105 +f 105 93 104 +f 95 94 106 +f 106 94 105 +f 107 108 96 +f 107 96 106 +f 106 96 95 +f 97 96 108 +f 100 99 109 +f 109 110 111 +f 109 111 100 +f 100 111 101 +f 102 101 112 +f 112 101 111 +f 103 102 113 +f 113 102 112 +f 104 103 114 +f 114 103 113 +f 105 104 115 +f 115 104 114 +f 116 117 106 +f 116 106 115 +f 115 106 105 +f 107 106 117 +f 111 110 118 +f 112 111 118 +f 119 112 118 +f 113 112 119 +f 120 113 119 +f 114 113 120 +f 121 114 120 +f 115 114 121 +f 122 115 121 +f 116 115 122 +f 2 123 124 +f 3 2 124 +f 5 125 2 +f 2 125 123 +f 7 126 5 +f 5 126 125 +f 9 127 7 +f 7 127 126 +f 11 128 9 +f 9 128 127 +f 128 11 12 +f 129 128 12 +f 14 130 131 +f 15 14 131 +f 124 14 3 +f 130 14 124 +f 12 132 129 +f 21 132 12 +f 132 21 23 +f 133 132 23 +f 25 134 135 +f 26 25 135 +f 131 25 15 +f 134 25 131 +f 23 136 133 +f 34 136 23 +f 136 34 36 +f 137 136 36 +f 38 138 139 +f 39 38 139 +f 135 38 26 +f 138 38 135 +f 36 49 137 +f 137 49 140 +f 39 139 51 +f 139 141 51 +f 49 61 140 +f 140 61 142 +f 51 141 63 +f 141 143 63 +f 61 73 142 +f 142 73 144 +f 63 143 75 +f 143 145 75 +f 73 85 144 +f 144 85 146 +f 75 145 147 +f 86 75 147 +f 147 87 86 +f 148 87 147 +f 85 97 146 +f 146 97 149 +f 87 148 150 +f 98 87 150 +f 150 99 98 +f 151 99 150 +f 108 152 153 +f 107 152 108 +f 149 97 108 +f 153 149 108 +f 99 151 154 +f 109 99 154 +f 154 110 109 +f 155 110 154 +f 117 156 157 +f 116 156 117 +f 152 107 117 +f 157 152 117 +f 110 155 158 +f 118 110 158 +f 119 118 159 +f 118 158 159 +f 120 119 160 +f 119 159 160 +f 121 120 161 +f 120 160 161 +f 122 121 162 +f 121 161 162 +f 156 116 122 +f 162 156 122 +f 123 163 164 +f 124 123 164 +f 125 165 123 +f 123 165 163 +f 126 166 125 +f 125 166 165 +f 127 167 126 +f 126 167 166 +f 128 168 127 +f 127 168 167 +f 168 128 129 +f 169 168 129 +f 130 170 171 +f 131 130 171 +f 164 130 124 +f 170 130 164 +f 129 172 169 +f 132 172 129 +f 172 132 133 +f 173 172 133 +f 134 174 175 +f 135 134 175 +f 171 134 131 +f 174 134 171 +f 133 176 173 +f 136 176 133 +f 176 136 137 +f 177 176 137 +f 138 178 179 +f 139 138 179 +f 175 138 135 +f 178 138 175 +f 137 140 177 +f 177 140 180 +f 139 179 141 +f 179 181 141 +f 140 142 180 +f 180 142 182 +f 141 181 143 +f 181 183 143 +f 142 144 182 +f 182 144 184 +f 143 183 145 +f 183 185 145 +f 144 146 184 +f 184 146 186 +f 145 185 187 +f 147 145 187 +f 187 148 147 +f 188 148 187 +f 146 149 186 +f 186 149 189 +f 148 188 190 +f 150 148 190 +f 190 151 150 +f 191 151 190 +f 153 192 193 +f 152 192 153 +f 189 149 153 +f 193 189 153 +f 151 191 194 +f 154 151 194 +f 194 155 154 +f 195 155 194 +f 157 196 197 +f 156 196 157 +f 192 152 157 +f 197 192 157 +f 155 195 198 +f 158 155 198 +f 159 158 199 +f 158 198 199 +f 160 159 200 +f 159 199 200 +f 161 160 201 +f 160 200 201 +f 162 161 202 +f 161 201 202 +f 196 156 162 +f 202 196 162 +f 163 203 204 +f 164 163 204 +f 165 205 163 +f 163 205 203 +f 166 206 165 +f 165 206 205 +f 167 207 166 +f 166 207 206 +f 168 208 167 +f 167 208 207 +f 208 168 169 +f 209 208 169 +f 170 210 211 +f 171 170 211 +f 204 170 164 +f 210 170 204 +f 169 212 209 +f 172 212 169 +f 212 172 173 +f 213 212 173 +f 174 214 215 +f 175 174 215 +f 211 174 171 +f 214 174 211 +f 173 216 213 +f 176 216 173 +f 216 176 177 +f 217 216 177 +f 178 218 219 +f 179 178 219 +f 215 178 175 +f 218 178 215 +f 177 180 217 +f 217 180 220 +f 179 219 181 +f 219 221 181 +f 180 182 220 +f 220 182 222 +f 181 221 183 +f 221 223 183 +f 182 184 222 +f 222 184 224 +f 183 223 185 +f 223 225 185 +f 184 186 224 +f 224 186 226 +f 185 225 227 +f 187 185 227 +f 227 188 187 +f 228 188 227 +f 186 189 226 +f 226 189 229 +f 188 228 230 +f 190 188 230 +f 230 191 190 +f 231 191 230 +f 193 232 233 +f 192 232 193 +f 229 189 193 +f 233 229 193 +f 191 231 234 +f 194 191 234 +f 234 195 194 +f 235 195 234 +f 197 236 237 +f 196 236 197 +f 232 192 197 +f 237 232 197 +f 195 235 238 +f 198 195 238 +f 199 198 239 +f 198 238 239 +f 200 199 240 +f 199 239 240 +f 201 200 241 +f 200 240 241 +f 202 201 242 +f 201 241 242 +f 236 196 202 +f 242 236 202 +f 203 243 244 +f 204 203 244 +f 205 245 203 +f 203 245 243 +f 206 246 205 +f 205 246 245 +f 207 247 206 +f 206 247 246 +f 208 248 207 +f 207 248 247 +f 248 208 209 +f 249 248 209 +f 210 250 251 +f 211 210 251 +f 244 210 204 +f 250 210 244 +f 209 252 249 +f 212 252 209 +f 252 212 213 +f 253 252 213 +f 214 254 255 +f 215 214 255 +f 251 214 211 +f 254 214 251 +f 213 256 253 +f 216 256 213 +f 256 216 217 +f 257 256 217 +f 218 258 259 +f 219 218 259 +f 255 218 215 +f 258 218 255 +f 217 220 257 +f 257 220 260 +f 219 259 221 +f 259 261 221 +f 220 222 260 +f 260 222 262 +f 221 261 223 +f 261 263 223 +f 222 224 262 +f 262 224 264 +f 223 263 225 +f 263 265 225 +f 224 226 264 +f 264 226 266 +f 225 265 267 +f 227 225 267 +f 267 228 227 +f 268 228 267 +f 226 229 266 +f 266 229 269 +f 228 268 270 +f 230 228 270 +f 270 231 230 +f 271 231 270 +f 233 272 273 +f 232 272 233 +f 269 229 233 +f 273 269 233 +f 231 271 274 +f 234 231 274 +f 274 235 234 +f 275 235 274 +f 237 276 277 +f 236 276 237 +f 272 232 237 +f 277 272 237 +f 235 275 278 +f 238 235 278 +f 239 238 279 +f 238 278 279 +f 240 239 280 +f 239 279 280 +f 241 240 281 +f 240 280 281 +f 242 241 282 +f 241 281 282 +f 276 236 242 +f 282 276 242 +f 243 283 284 +f 244 243 284 +f 245 285 243 +f 243 285 283 +f 246 286 245 +f 245 286 285 +f 247 287 246 +f 246 287 286 +f 248 288 247 +f 247 288 287 +f 288 248 249 +f 289 288 249 +f 250 290 291 +f 251 250 291 +f 284 250 244 +f 290 250 284 +f 249 292 289 +f 252 292 249 +f 292 252 253 +f 293 292 253 +f 254 294 295 +f 255 254 295 +f 291 254 251 +f 294 254 291 +f 253 296 293 +f 256 296 253 +f 296 256 257 +f 297 296 257 +f 258 298 299 +f 259 258 299 +f 295 258 255 +f 298 258 295 +f 257 260 297 +f 297 260 300 +f 259 299 261 +f 299 301 261 +f 260 262 300 +f 300 262 302 +f 261 301 263 +f 301 303 263 +f 262 264 302 +f 302 264 304 +f 263 303 265 +f 303 305 265 +f 264 266 304 +f 304 266 306 +f 265 305 307 +f 267 265 307 +f 307 268 267 +f 308 268 307 +f 266 269 306 +f 306 269 309 +f 268 308 310 +f 270 268 310 +f 310 271 270 +f 311 271 310 +f 273 312 313 +f 272 312 273 +f 309 269 273 +f 313 309 273 +f 271 311 314 +f 274 271 314 +f 314 275 274 +f 315 275 314 +f 277 316 317 +f 276 316 277 +f 312 272 277 +f 317 312 277 +f 275 315 318 +f 278 275 318 +f 279 278 319 +f 278 318 319 +f 280 279 320 +f 279 319 320 +f 281 280 321 +f 280 320 321 +f 282 281 322 +f 281 321 322 +f 316 276 282 +f 322 316 282 +f 283 323 324 +f 284 283 324 +f 285 325 283 +f 283 325 323 +f 286 326 285 +f 285 326 325 +f 287 327 286 +f 286 327 326 +f 288 328 287 +f 287 328 327 +f 328 288 289 +f 329 328 289 +f 290 330 331 +f 291 290 331 +f 324 290 284 +f 330 290 324 +f 289 332 329 +f 292 332 289 +f 332 292 293 +f 333 332 293 +f 294 334 335 +f 295 294 335 +f 331 294 291 +f 334 294 331 +f 293 336 333 +f 296 336 293 +f 336 296 297 +f 337 336 297 +f 298 338 339 +f 299 298 339 +f 335 298 295 +f 338 298 335 +f 297 300 337 +f 337 300 340 +f 299 339 301 +f 339 341 301 +f 300 302 340 +f 340 302 342 +f 301 341 303 +f 341 343 303 +f 302 304 342 +f 342 304 344 +f 303 343 305 +f 343 345 305 +f 304 306 344 +f 344 306 346 +f 305 345 347 +f 307 305 347 +f 347 308 307 +f 348 308 347 +f 306 309 346 +f 346 309 349 +f 308 348 350 +f 310 308 350 +f 350 311 310 +f 351 311 350 +f 313 352 353 +f 312 352 313 +f 349 309 313 +f 353 349 313 +f 311 351 354 +f 314 311 354 +f 354 315 314 +f 355 315 354 +f 317 356 357 +f 316 356 317 +f 352 312 317 +f 357 352 317 +f 315 355 358 +f 318 315 358 +f 319 318 359 +f 318 358 359 +f 320 319 360 +f 319 359 360 +f 321 320 361 +f 320 360 361 +f 322 321 362 +f 321 361 362 +f 356 316 322 +f 362 356 322 +f 363 364 365 +f 363 366 367 +f 364 363 367 +f 366 368 369 +f 367 366 369 +f 368 370 371 +f 369 368 371 +f 370 372 373 +f 371 370 373 +f 372 374 375 +f 373 372 375 +f 374 376 377 +f 375 374 377 +f 376 378 379 +f 377 376 379 +f 378 380 381 +f 379 378 381 +f 380 382 383 +f 381 380 383 +f 382 384 385 +f 383 382 385 +f 384 386 387 +f 385 384 387 +f 386 388 389 +f 387 386 389 +f 388 390 391 +f 389 388 391 +f 390 392 393 +f 391 390 393 +f 393 392 394 +f 395 363 365 +f 396 395 365 +f 366 363 397 +f 397 363 395 +f 368 366 398 +f 398 366 397 +f 370 368 399 +f 399 368 398 +f 372 370 400 +f 400 370 399 +f 374 372 401 +f 401 372 400 +f 376 374 402 +f 402 374 401 +f 378 376 403 +f 403 376 402 +f 380 378 404 +f 404 378 403 +f 382 380 405 +f 405 380 404 +f 384 382 406 +f 406 382 405 +f 386 384 407 +f 407 384 406 +f 388 386 408 +f 408 386 407 +f 390 388 409 +f 409 388 408 +f 392 390 410 +f 410 390 409 +f 411 394 392 +f 410 411 392 +f 412 395 396 +f 413 412 396 +f 397 395 414 +f 414 395 412 +f 398 397 415 +f 415 397 414 +f 399 398 416 +f 416 398 415 +f 400 399 417 +f 417 399 416 +f 323 417 324 +f 323 401 417 +f 401 400 417 +f 325 401 323 +f 402 401 325 +f 326 402 325 +f 403 402 326 +f 327 403 326 +f 404 403 327 +f 328 404 327 +f 405 404 328 +f 329 405 328 +f 329 418 405 +f 418 406 405 +f 407 406 419 +f 419 406 418 +f 408 407 420 +f 420 407 419 +f 409 408 421 +f 421 408 420 +f 410 409 422 +f 422 409 421 +f 423 411 410 +f 422 423 410 +f 424 412 413 +f 425 424 413 +f 414 412 426 +f 426 412 424 +f 415 414 427 +f 427 414 426 +f 416 415 428 +f 428 415 427 +f 330 428 331 +f 330 417 428 +f 417 416 428 +f 324 417 330 +f 329 332 418 +f 333 418 332 +f 333 429 418 +f 429 419 418 +f 420 419 430 +f 430 419 429 +f 421 420 431 +f 431 420 430 +f 422 421 432 +f 432 421 431 +f 433 423 422 +f 432 433 422 +f 434 424 425 +f 435 434 425 +f 426 424 436 +f 436 424 434 +f 427 426 437 +f 437 426 436 +f 334 437 335 +f 334 428 437 +f 428 427 437 +f 331 428 334 +f 333 336 429 +f 337 429 336 +f 337 438 429 +f 438 430 429 +f 431 430 439 +f 439 430 438 +f 432 431 440 +f 440 431 439 +f 441 433 432 +f 440 441 432 +f 442 434 435 +f 443 442 435 +f 436 434 444 +f 444 434 442 +f 338 444 339 +f 338 437 444 +f 437 436 444 +f 335 437 338 +f 438 340 445 +f 337 340 438 +f 439 438 446 +f 446 438 445 +f 440 439 447 +f 447 439 446 +f 448 441 440 +f 447 448 440 +f 449 442 443 +f 450 449 443 +f 444 442 451 +f 451 442 449 +f 339 451 341 +f 444 451 339 +f 445 342 452 +f 340 342 445 +f 446 445 453 +f 453 445 452 +f 447 446 454 +f 454 446 453 +f 455 448 447 +f 454 455 447 +f 456 449 450 +f 457 456 450 +f 451 449 458 +f 458 449 456 +f 341 458 343 +f 451 458 341 +f 452 344 459 +f 342 344 452 +f 453 452 460 +f 460 452 459 +f 454 453 461 +f 461 453 460 +f 462 455 454 +f 461 462 454 +f 463 456 457 +f 464 463 457 +f 458 456 465 +f 465 456 463 +f 343 465 345 +f 458 465 343 +f 459 346 466 +f 344 346 459 +f 460 459 467 +f 467 459 466 +f 461 460 468 +f 468 460 467 +f 469 462 461 +f 468 469 461 +f 470 463 464 +f 471 470 464 +f 465 463 472 +f 472 463 470 +f 345 473 347 +f 345 465 473 +f 465 472 473 +f 347 473 348 +f 466 349 474 +f 346 349 466 +f 467 466 475 +f 475 466 474 +f 468 467 476 +f 476 467 475 +f 477 469 468 +f 476 477 468 +f 478 470 471 +f 479 478 471 +f 472 470 480 +f 480 470 478 +f 473 472 481 +f 481 472 480 +f 348 482 350 +f 348 473 482 +f 473 481 482 +f 350 482 351 +f 353 352 483 +f 353 474 349 +f 353 483 474 +f 483 484 474 +f 475 474 485 +f 485 474 484 +f 476 475 486 +f 486 475 485 +f 487 477 476 +f 486 487 476 +f 488 478 479 +f 489 488 479 +f 480 478 490 +f 490 478 488 +f 481 480 491 +f 491 480 490 +f 482 481 492 +f 492 481 491 +f 351 493 354 +f 351 482 493 +f 482 492 493 +f 354 493 355 +f 357 356 494 +f 357 483 352 +f 357 494 483 +f 494 495 483 +f 484 483 496 +f 496 483 495 +f 485 484 497 +f 497 484 496 +f 486 485 498 +f 498 485 497 +f 499 487 486 +f 498 499 486 +f 500 488 489 +f 501 500 489 +f 490 488 502 +f 502 488 500 +f 491 490 503 +f 503 490 502 +f 492 491 504 +f 504 491 503 +f 493 492 505 +f 505 492 504 +f 355 506 358 +f 355 493 506 +f 493 505 506 +f 358 507 359 +f 506 507 358 +f 359 508 360 +f 507 508 359 +f 360 509 361 +f 508 509 360 +f 361 510 362 +f 509 510 361 +f 362 494 356 +f 362 510 494 +f 510 511 494 +f 495 494 512 +f 512 494 511 +f 496 495 513 +f 513 495 512 +f 497 496 514 +f 514 496 513 +f 498 497 515 +f 515 497 514 +f 516 499 498 +f 515 516 498 +f 517 500 501 +f 518 517 501 +f 502 500 519 +f 519 500 517 +f 503 502 520 +f 520 502 519 +f 504 503 521 +f 521 503 520 +f 505 504 522 +f 522 504 521 +f 506 505 523 +f 523 505 522 +f 507 506 524 +f 524 506 523 +f 508 507 525 +f 525 507 524 +f 509 508 526 +f 526 508 525 +f 510 509 527 +f 527 509 526 +f 511 510 528 +f 528 510 527 +f 512 511 529 +f 529 511 528 +f 513 512 530 +f 530 512 529 +f 514 513 531 +f 531 513 530 +f 515 514 532 +f 532 514 531 +f 533 516 515 +f 532 533 515 +f 517 518 534 +f 519 517 534 +f 535 519 534 +f 520 519 535 +f 536 520 535 +f 521 520 536 +f 537 521 536 +f 522 521 537 +f 538 522 537 +f 523 522 538 +f 539 523 538 +f 524 523 539 +f 540 524 539 +f 525 524 540 +f 541 525 540 +f 526 525 541 +f 542 526 541 +f 527 526 542 +f 543 527 542 +f 528 527 543 +f 544 528 543 +f 529 528 544 +f 545 529 544 +f 530 529 545 +f 546 530 545 +f 531 530 546 +f 547 531 546 +f 532 531 547 +f 548 532 547 +f 533 532 548 +f 364 549 550 +f 365 364 550 +f 367 551 364 +f 364 551 549 +f 369 552 367 +f 367 552 551 +f 371 553 369 +f 369 553 552 +f 373 554 371 +f 371 554 553 +f 375 555 373 +f 373 555 554 +f 377 556 375 +f 375 556 555 +f 379 557 377 +f 377 557 556 +f 381 558 379 +f 379 558 557 +f 383 559 381 +f 381 559 558 +f 385 560 383 +f 383 560 559 +f 387 561 385 +f 385 561 560 +f 389 562 387 +f 387 562 561 +f 391 563 389 +f 389 563 562 +f 393 564 391 +f 391 564 563 +f 564 393 394 +f 565 564 394 +f 365 550 396 +f 550 566 396 +f 394 411 565 +f 565 411 567 +f 396 566 413 +f 566 568 413 +f 411 423 567 +f 567 423 569 +f 413 568 425 +f 568 570 425 +f 423 433 569 +f 569 433 571 +f 425 570 435 +f 570 572 435 +f 433 441 571 +f 571 441 573 +f 435 572 443 +f 572 574 443 +f 441 448 573 +f 573 448 575 +f 443 574 450 +f 574 576 450 +f 448 455 575 +f 575 455 577 +f 450 576 457 +f 576 578 457 +f 455 462 577 +f 577 462 579 +f 457 578 464 +f 578 580 464 +f 462 469 579 +f 579 469 581 +f 464 580 471 +f 580 582 471 +f 469 477 581 +f 581 477 583 +f 471 582 479 +f 582 584 479 +f 477 487 583 +f 583 487 585 +f 479 584 489 +f 584 586 489 +f 487 499 585 +f 585 499 587 +f 489 586 501 +f 586 588 501 +f 499 516 587 +f 587 516 589 +f 501 588 518 +f 588 590 518 +f 516 533 589 +f 589 533 591 +f 518 590 592 +f 534 518 592 +f 535 534 593 +f 534 592 593 +f 536 535 594 +f 535 593 594 +f 537 536 595 +f 536 594 595 +f 538 537 596 +f 537 595 596 +f 539 538 597 +f 538 596 597 +f 540 539 598 +f 539 597 598 +f 541 540 599 +f 540 598 599 +f 542 541 600 +f 541 599 600 +f 543 542 601 +f 542 600 601 +f 544 543 602 +f 543 601 602 +f 545 544 603 +f 544 602 603 +f 546 545 604 +f 545 603 604 +f 547 546 605 +f 546 604 605 +f 548 547 606 +f 547 605 606 +f 591 533 548 +f 606 591 548 +f 549 607 608 +f 550 549 608 +f 551 609 549 +f 549 609 607 +f 552 610 551 +f 551 610 609 +f 553 611 552 +f 552 611 610 +f 554 612 553 +f 553 612 611 +f 555 613 554 +f 554 613 612 +f 556 614 555 +f 555 614 613 +f 557 615 556 +f 556 615 614 +f 558 616 557 +f 557 616 615 +f 559 617 558 +f 558 617 616 +f 560 618 559 +f 559 618 617 +f 561 619 560 +f 560 619 618 +f 562 620 561 +f 561 620 619 +f 563 621 562 +f 562 621 620 +f 564 622 563 +f 563 622 621 +f 622 564 565 +f 623 622 565 +f 550 608 566 +f 608 624 566 +f 565 567 623 +f 623 567 625 +f 566 624 568 +f 624 626 568 +f 567 569 625 +f 625 569 627 +f 568 626 570 +f 626 628 570 +f 569 571 627 +f 627 571 629 +f 570 628 572 +f 628 630 572 +f 571 573 629 +f 629 573 631 +f 572 630 574 +f 630 632 574 +f 573 575 631 +f 631 575 633 +f 574 632 576 +f 632 634 576 +f 575 577 633 +f 633 577 635 +f 576 634 578 +f 634 636 578 +f 577 579 635 +f 635 579 637 +f 578 636 580 +f 636 638 580 +f 579 581 637 +f 637 581 639 +f 580 638 582 +f 638 640 582 +f 581 583 639 +f 639 583 641 +f 582 640 584 +f 640 642 584 +f 583 585 641 +f 641 585 643 +f 584 642 586 +f 642 644 586 +f 585 587 643 +f 643 587 645 +f 586 644 588 +f 644 646 588 +f 587 589 645 +f 645 589 647 +f 588 646 590 +f 646 648 590 +f 589 591 647 +f 647 591 649 +f 590 648 650 +f 592 590 650 +f 593 592 651 +f 592 650 651 +f 594 593 652 +f 593 651 652 +f 595 594 653 +f 594 652 653 +f 596 595 654 +f 595 653 654 +f 597 596 655 +f 596 654 655 +f 598 597 656 +f 597 655 656 +f 599 598 657 +f 598 656 657 +f 600 599 658 +f 599 657 658 +f 601 600 659 +f 600 658 659 +f 602 601 660 +f 601 659 660 +f 603 602 661 +f 602 660 661 +f 604 603 662 +f 603 661 662 +f 605 604 663 +f 604 662 663 +f 606 605 664 +f 605 663 664 +f 649 591 606 +f 664 649 606 +f 607 665 666 +f 608 607 666 +f 609 667 607 +f 607 667 665 +f 610 668 609 +f 609 668 667 +f 611 669 610 +f 610 669 668 +f 612 670 611 +f 611 670 669 +f 671 672 670 +f 671 670 613 +f 613 670 612 +f 613 614 673 +f 671 613 673 +f 614 615 674 +f 673 614 674 +f 615 616 675 +f 674 615 675 +f 616 617 676 +f 675 616 676 +f 677 676 617 +f 677 617 678 +f 678 617 618 +f 619 679 618 +f 618 679 678 +f 620 680 619 +f 619 680 679 +f 621 681 620 +f 620 681 680 +f 622 682 621 +f 621 682 681 +f 682 622 623 +f 683 682 623 +f 608 666 624 +f 666 684 624 +f 685 672 671 +f 686 672 685 +f 673 687 671 +f 687 685 671 +f 674 688 673 +f 688 687 673 +f 675 689 674 +f 689 688 674 +f 676 690 675 +f 690 689 675 +f 691 676 677 +f 690 676 691 +f 623 625 683 +f 683 625 692 +f 624 684 626 +f 684 693 626 +f 694 686 685 +f 695 686 694 +f 687 696 685 +f 696 694 685 +f 688 697 687 +f 697 696 687 +f 689 698 688 +f 698 697 688 +f 690 699 689 +f 699 698 689 +f 700 690 691 +f 699 690 700 +f 625 627 692 +f 692 627 701 +f 626 693 628 +f 693 702 628 +f 703 695 694 +f 704 695 703 +f 696 705 694 +f 705 703 694 +f 697 706 696 +f 706 705 696 +f 698 707 697 +f 707 706 697 +f 699 708 698 +f 708 707 698 +f 709 699 700 +f 708 699 709 +f 627 629 701 +f 701 629 710 +f 711 712 630 +f 711 630 702 +f 702 630 628 +f 712 713 714 +f 711 713 712 +f 714 715 716 +f 713 715 714 +f 716 717 718 +f 715 717 716 +f 718 719 720 +f 717 719 718 +f 704 720 719 +f 704 703 720 +f 703 721 720 +f 705 722 703 +f 722 721 703 +f 706 723 705 +f 723 722 705 +f 707 724 706 +f 724 723 706 +f 708 725 707 +f 725 724 707 +f 726 708 709 +f 726 727 708 +f 727 725 708 +f 727 728 729 +f 726 728 727 +f 729 730 731 +f 728 730 729 +f 731 732 733 +f 730 732 731 +f 733 734 735 +f 732 734 733 +f 735 734 710 +f 735 710 631 +f 631 710 629 +f 712 736 632 +f 630 712 632 +f 714 737 712 +f 737 736 712 +f 716 738 714 +f 738 737 714 +f 718 739 716 +f 739 738 716 +f 720 740 718 +f 740 739 718 +f 721 741 720 +f 741 740 720 +f 722 742 721 +f 742 741 721 +f 723 743 722 +f 743 742 722 +f 724 744 723 +f 744 743 723 +f 725 745 724 +f 745 744 724 +f 727 746 725 +f 746 745 725 +f 729 747 727 +f 747 746 727 +f 731 748 729 +f 748 747 729 +f 733 749 731 +f 749 748 731 +f 735 750 733 +f 750 749 733 +f 631 633 750 +f 735 631 750 +f 736 751 634 +f 632 736 634 +f 737 752 736 +f 752 751 736 +f 738 753 737 +f 753 752 737 +f 739 754 738 +f 754 753 738 +f 740 755 739 +f 755 754 739 +f 741 756 740 +f 756 755 740 +f 742 757 741 +f 757 756 741 +f 743 758 742 +f 758 757 742 +f 744 759 743 +f 759 758 743 +f 745 760 744 +f 760 759 744 +f 746 761 745 +f 761 760 745 +f 747 762 746 +f 762 761 746 +f 748 763 747 +f 763 762 747 +f 749 764 748 +f 764 763 748 +f 750 765 749 +f 765 764 749 +f 633 635 765 +f 750 633 765 +f 751 766 636 +f 634 751 636 +f 752 767 751 +f 767 766 751 +f 753 768 752 +f 768 767 752 +f 754 769 753 +f 769 768 753 +f 755 770 754 +f 770 769 754 +f 756 771 755 +f 771 770 755 +f 757 772 756 +f 772 771 756 +f 758 773 757 +f 773 772 757 +f 759 774 758 +f 774 773 758 +f 760 775 759 +f 775 774 759 +f 761 776 760 +f 776 775 760 +f 762 777 761 +f 777 776 761 +f 763 778 762 +f 778 777 762 +f 764 779 763 +f 779 778 763 +f 765 780 764 +f 780 779 764 +f 635 637 780 +f 765 635 780 +f 766 781 638 +f 636 766 638 +f 767 782 766 +f 782 781 766 +f 768 783 767 +f 783 782 767 +f 769 784 768 +f 784 783 768 +f 770 785 769 +f 785 784 769 +f 771 786 770 +f 786 785 770 +f 772 787 771 +f 787 786 771 +f 773 788 772 +f 788 787 772 +f 774 789 773 +f 789 788 773 +f 775 790 774 +f 790 789 774 +f 776 791 775 +f 791 790 775 +f 777 792 776 +f 792 791 776 +f 778 793 777 +f 793 792 777 +f 779 794 778 +f 794 793 778 +f 780 795 779 +f 795 794 779 +f 637 639 795 +f 780 637 795 +f 781 796 640 +f 638 781 640 +f 782 797 781 +f 797 796 781 +f 783 798 782 +f 798 797 782 +f 784 799 783 +f 799 798 783 +f 785 800 784 +f 800 799 784 +f 786 801 785 +f 801 800 785 +f 787 802 786 +f 802 801 786 +f 788 803 787 +f 803 802 787 +f 789 804 788 +f 804 803 788 +f 790 805 789 +f 805 804 789 +f 791 806 790 +f 806 805 790 +f 792 807 791 +f 807 806 791 +f 793 808 792 +f 808 807 792 +f 794 809 793 +f 809 808 793 +f 795 810 794 +f 810 809 794 +f 639 641 810 +f 795 639 810 +f 796 811 812 +f 796 812 640 +f 640 812 642 +f 797 811 796 +f 813 811 797 +f 798 813 797 +f 814 813 798 +f 799 814 798 +f 815 814 799 +f 800 815 799 +f 816 815 800 +f 816 817 818 +f 816 800 817 +f 800 801 817 +f 802 819 801 +f 819 817 801 +f 803 820 802 +f 820 819 802 +f 804 821 803 +f 821 820 803 +f 805 822 804 +f 822 821 804 +f 823 806 824 +f 823 822 806 +f 822 805 806 +f 807 824 806 +f 825 824 807 +f 808 825 807 +f 826 825 808 +f 809 826 808 +f 827 826 809 +f 810 827 809 +f 828 827 810 +f 828 810 641 +f 828 641 829 +f 829 641 643 +f 642 812 644 +f 812 830 644 +f 831 818 817 +f 832 818 831 +f 819 833 817 +f 833 831 817 +f 820 834 819 +f 834 833 819 +f 821 835 820 +f 835 834 820 +f 822 836 821 +f 836 835 821 +f 837 822 823 +f 836 822 837 +f 643 645 829 +f 829 645 838 +f 644 830 646 +f 830 839 646 +f 840 832 831 +f 841 832 840 +f 833 842 831 +f 842 840 831 +f 834 843 833 +f 843 842 833 +f 835 844 834 +f 844 843 834 +f 836 845 835 +f 845 844 835 +f 846 836 837 +f 845 836 846 +f 645 647 838 +f 838 647 847 +f 646 839 648 +f 839 848 648 +f 849 841 840 +f 850 841 849 +f 842 851 840 +f 851 849 840 +f 843 852 842 +f 852 851 842 +f 844 853 843 +f 853 852 843 +f 845 854 844 +f 854 853 844 +f 855 845 846 +f 854 845 855 +f 647 649 847 +f 847 649 856 +f 648 848 857 +f 650 648 857 +f 651 650 858 +f 650 857 858 +f 652 651 859 +f 651 858 859 +f 653 652 860 +f 652 859 860 +f 654 653 861 +f 653 860 861 +f 850 849 655 +f 850 655 861 +f 861 655 654 +f 656 655 849 +f 851 656 849 +f 657 656 851 +f 852 657 851 +f 658 657 852 +f 853 658 852 +f 659 658 853 +f 854 659 853 +f 854 855 862 +f 854 862 659 +f 659 862 660 +f 661 660 863 +f 660 862 863 +f 662 661 864 +f 661 863 864 +f 663 662 865 +f 662 864 865 +f 664 663 866 +f 663 865 866 +f 856 649 664 +f 866 856 664 +f 665 867 868 +f 666 665 868 +f 667 869 665 +f 665 869 867 +f 668 870 667 +f 667 870 869 +f 669 871 668 +f 668 871 870 +f 872 873 871 +f 872 871 670 +f 670 871 669 +f 670 672 872 +f 678 874 677 +f 875 874 678 +f 875 678 876 +f 876 678 679 +f 680 877 679 +f 679 877 876 +f 681 878 680 +f 680 878 877 +f 682 879 681 +f 681 879 878 +f 879 682 683 +f 880 879 683 +f 666 868 684 +f 868 881 684 +f 882 873 872 +f 883 873 882 +f 672 686 882 +f 872 672 882 +f 874 884 691 +f 677 874 691 +f 885 874 875 +f 884 874 885 +f 683 692 880 +f 880 692 886 +f 684 881 693 +f 881 887 693 +f 888 883 882 +f 889 883 888 +f 686 695 888 +f 882 686 888 +f 884 890 700 +f 691 884 700 +f 891 884 885 +f 890 884 891 +f 692 701 886 +f 886 701 892 +f 893 894 702 +f 893 702 887 +f 887 702 693 +f 894 895 896 +f 893 895 894 +f 896 897 898 +f 895 897 896 +f 898 899 900 +f 897 899 898 +f 889 900 899 +f 889 888 900 +f 888 901 900 +f 695 704 901 +f 888 695 901 +f 890 902 709 +f 700 890 709 +f 903 890 891 +f 903 904 890 +f 904 902 890 +f 904 905 906 +f 903 905 904 +f 906 907 908 +f 905 907 906 +f 908 909 910 +f 907 909 908 +f 910 909 892 +f 910 892 710 +f 710 892 701 +f 702 894 711 +f 713 711 894 +f 896 713 894 +f 715 713 896 +f 898 715 896 +f 717 715 898 +f 900 717 898 +f 719 717 900 +f 901 719 900 +f 704 719 901 +f 709 902 726 +f 728 726 902 +f 904 728 902 +f 730 728 904 +f 906 730 904 +f 732 730 906 +f 908 732 906 +f 734 732 908 +f 910 734 908 +f 710 734 910 +f 811 911 812 +f 811 813 912 +f 911 811 912 +f 813 814 913 +f 912 813 913 +f 814 815 914 +f 913 814 914 +f 815 816 915 +f 914 815 915 +f 816 818 915 +f 824 916 823 +f 824 825 917 +f 916 824 917 +f 825 826 918 +f 917 825 918 +f 826 827 919 +f 918 826 919 +f 827 828 920 +f 919 827 920 +f 828 829 920 +f 911 921 922 +f 911 922 812 +f 812 922 830 +f 912 921 911 +f 923 921 912 +f 913 923 912 +f 924 923 913 +f 914 924 913 +f 925 924 914 +f 925 926 927 +f 925 914 926 +f 914 915 926 +f 818 832 926 +f 915 818 926 +f 916 928 837 +f 823 916 837 +f 929 917 930 +f 929 928 917 +f 928 916 917 +f 918 930 917 +f 931 930 918 +f 919 931 918 +f 932 931 919 +f 920 932 919 +f 933 932 920 +f 933 920 829 +f 933 829 934 +f 934 829 838 +f 830 922 839 +f 922 935 839 +f 936 927 926 +f 937 927 936 +f 832 841 936 +f 926 832 936 +f 928 938 846 +f 837 928 846 +f 939 928 929 +f 938 928 939 +f 838 847 934 +f 934 847 940 +f 839 935 848 +f 935 941 848 +f 942 937 936 +f 943 937 942 +f 841 850 942 +f 936 841 942 +f 938 944 855 +f 846 938 855 +f 945 938 939 +f 944 938 945 +f 847 856 940 +f 940 856 946 +f 848 941 947 +f 857 848 947 +f 858 857 948 +f 857 947 948 +f 859 858 949 +f 858 948 949 +f 860 859 950 +f 859 949 950 +f 943 942 861 +f 943 861 950 +f 950 861 860 +f 850 861 942 +f 855 944 862 +f 944 945 951 +f 944 951 862 +f 862 951 863 +f 864 863 952 +f 863 951 952 +f 865 864 953 +f 864 952 953 +f 866 865 954 +f 865 953 954 +f 946 856 866 +f 954 946 866 +f 867 955 956 +f 868 867 956 +f 869 957 867 +f 867 957 955 +f 870 958 869 +f 869 958 957 +f 959 960 958 +f 959 958 871 +f 871 958 870 +f 871 873 959 +f 876 961 962 +f 875 876 962 +f 877 963 876 +f 876 963 961 +f 878 964 877 +f 877 964 963 +f 879 965 878 +f 878 965 964 +f 965 879 880 +f 966 965 880 +f 868 956 881 +f 956 967 881 +f 968 960 959 +f 969 960 968 +f 873 883 968 +f 959 873 968 +f 875 962 885 +f 962 970 885 +f 880 886 966 +f 966 886 971 +f 881 967 887 +f 967 972 887 +f 973 969 968 +f 974 969 973 +f 883 889 973 +f 968 883 973 +f 885 970 891 +f 970 975 891 +f 886 892 971 +f 971 892 976 +f 887 972 977 +f 893 887 977 +f 895 893 978 +f 893 977 978 +f 897 895 979 +f 895 978 979 +f 974 973 899 +f 974 899 979 +f 979 899 897 +f 889 899 973 +f 891 975 980 +f 903 891 980 +f 905 903 981 +f 903 980 981 +f 907 905 982 +f 905 981 982 +f 909 907 983 +f 907 982 983 +f 976 892 909 +f 983 976 909 +f 921 984 985 +f 922 921 985 +f 923 986 921 +f 921 986 984 +f 924 987 923 +f 923 987 986 +f 988 989 987 +f 988 987 925 +f 925 987 924 +f 925 927 988 +f 930 990 991 +f 929 930 991 +f 931 992 930 +f 930 992 990 +f 932 993 931 +f 931 993 992 +f 933 994 932 +f 932 994 993 +f 994 933 934 +f 995 994 934 +f 922 985 935 +f 985 996 935 +f 997 989 988 +f 998 989 997 +f 927 937 997 +f 988 927 997 +f 929 991 939 +f 991 999 939 +f 934 940 995 +f 995 940 1000 +f 935 996 941 +f 996 1001 941 +f 1002 998 997 +f 1003 998 1002 +f 937 943 1002 +f 997 937 1002 +f 939 999 945 +f 999 1004 945 +f 940 946 1000 +f 1000 946 1005 +f 941 1001 1006 +f 947 941 1006 +f 948 947 1007 +f 947 1006 1007 +f 949 948 1008 +f 948 1007 1008 +f 1003 1002 950 +f 1003 950 1008 +f 1008 950 949 +f 943 950 1002 +f 945 1004 1009 +f 951 945 1009 +f 952 951 1010 +f 951 1009 1010 +f 953 952 1011 +f 952 1010 1011 +f 954 953 1012 +f 953 1011 1012 +f 1005 946 954 +f 1012 1005 954 +f 955 1013 1014 +f 956 955 1014 +f 957 1015 955 +f 955 1015 1013 +f 958 1016 957 +f 957 1016 1015 +f 1016 958 960 +f 1017 1016 960 +f 961 1018 962 +f 1019 1018 961 +f 1019 961 1020 +f 1020 961 963 +f 964 1021 963 +f 963 1021 1020 +f 965 1022 964 +f 964 1022 1021 +f 1022 965 966 +f 1023 1022 966 +f 956 1014 967 +f 1014 1024 967 +f 960 969 1017 +f 1017 969 1025 +f 1018 1026 970 +f 962 1018 970 +f 1027 1018 1019 +f 1026 1018 1027 +f 966 971 1023 +f 1023 971 1028 +f 967 1024 972 +f 1024 1029 972 +f 969 974 1025 +f 1025 974 1030 +f 1026 1031 975 +f 970 1026 975 +f 1032 1026 1027 +f 1031 1026 1032 +f 971 976 1028 +f 1028 976 1033 +f 972 1029 1034 +f 977 972 1034 +f 978 977 1035 +f 977 1034 1035 +f 979 978 1036 +f 978 1035 1036 +f 1030 974 979 +f 1036 1030 979 +f 975 1031 980 +f 1031 1032 1037 +f 1031 1037 980 +f 980 1037 981 +f 982 981 1038 +f 981 1037 1038 +f 983 982 1039 +f 982 1038 1039 +f 1033 976 983 +f 1039 1033 983 +f 984 1040 1041 +f 985 984 1041 +f 986 1042 984 +f 984 1042 1040 +f 987 1043 986 +f 986 1043 1042 +f 1043 987 989 +f 1044 1043 989 +f 990 1045 991 +f 1046 1045 990 +f 1046 990 1047 +f 1047 990 992 +f 993 1048 992 +f 992 1048 1047 +f 994 1049 993 +f 993 1049 1048 +f 1049 994 995 +f 1050 1049 995 +f 985 1041 996 +f 1041 1051 996 +f 989 998 1044 +f 1044 998 1052 +f 1045 1053 999 +f 991 1045 999 +f 1054 1045 1046 +f 1053 1045 1054 +f 995 1000 1050 +f 1050 1000 1055 +f 996 1051 1001 +f 1051 1056 1001 +f 998 1003 1052 +f 1052 1003 1057 +f 1053 1058 1004 +f 999 1053 1004 +f 1059 1053 1054 +f 1058 1053 1059 +f 1000 1005 1055 +f 1055 1005 1060 +f 1001 1056 1061 +f 1006 1001 1061 +f 1007 1006 1062 +f 1006 1061 1062 +f 1008 1007 1063 +f 1007 1062 1063 +f 1057 1003 1008 +f 1063 1057 1008 +f 1004 1058 1009 +f 1058 1059 1064 +f 1058 1064 1009 +f 1009 1064 1010 +f 1011 1010 1065 +f 1010 1064 1065 +f 1012 1011 1066 +f 1011 1065 1066 +f 1060 1005 1012 +f 1066 1060 1012 +f 1013 1067 1068 +f 1014 1013 1068 +f 1015 1069 1013 +f 1013 1069 1067 +f 1016 1070 1015 +f 1015 1070 1069 +f 1070 1016 1017 +f 1071 1070 1017 +f 1020 1072 1073 +f 1019 1020 1073 +f 1021 1074 1020 +f 1020 1074 1072 +f 1022 1075 1021 +f 1021 1075 1074 +f 1075 1022 1023 +f 1076 1075 1023 +f 1014 1068 1024 +f 1068 1077 1024 +f 1017 1025 1071 +f 1071 1025 1078 +f 1019 1073 1027 +f 1073 1079 1027 +f 1023 1028 1076 +f 1076 1028 1080 +f 1024 1077 1029 +f 1077 1081 1029 +f 1025 1030 1078 +f 1078 1030 1082 +f 1027 1079 1032 +f 1079 1083 1032 +f 1028 1033 1080 +f 1080 1033 1084 +f 1029 1081 1085 +f 1034 1029 1085 +f 1035 1034 1086 +f 1034 1085 1086 +f 1036 1035 1087 +f 1035 1086 1087 +f 1082 1030 1036 +f 1087 1082 1036 +f 1032 1083 1088 +f 1037 1032 1088 +f 1038 1037 1089 +f 1037 1088 1089 +f 1039 1038 1090 +f 1038 1089 1090 +f 1084 1033 1039 +f 1090 1084 1039 +f 1040 1091 1092 +f 1041 1040 1092 +f 1042 1093 1040 +f 1040 1093 1091 +f 1043 1094 1042 +f 1042 1094 1093 +f 1094 1043 1044 +f 1095 1094 1044 +f 1047 1096 1097 +f 1046 1047 1097 +f 1048 1098 1047 +f 1047 1098 1096 +f 1049 1099 1048 +f 1048 1099 1098 +f 1099 1049 1050 +f 1100 1099 1050 +f 1041 1092 1051 +f 1092 1101 1051 +f 1044 1052 1095 +f 1095 1052 1102 +f 1046 1097 1054 +f 1097 1103 1054 +f 1050 1055 1100 +f 1100 1055 1104 +f 1051 1101 1056 +f 1101 1105 1056 +f 1052 1057 1102 +f 1102 1057 1106 +f 1054 1103 1059 +f 1103 1107 1059 +f 1055 1060 1104 +f 1104 1060 1108 +f 1056 1105 1109 +f 1061 1056 1109 +f 1062 1061 1110 +f 1061 1109 1110 +f 1063 1062 1111 +f 1062 1110 1111 +f 1106 1057 1063 +f 1111 1106 1063 +f 1059 1107 1112 +f 1064 1059 1112 +f 1065 1064 1113 +f 1064 1112 1113 +f 1066 1065 1114 +f 1065 1113 1114 +f 1108 1060 1066 +f 1114 1108 1066 +f 1067 1115 1116 +f 1068 1067 1116 +f 1069 1117 1067 +f 1067 1117 1115 +f 1070 1118 1069 +f 1069 1118 1117 +f 1118 1070 1071 +f 1119 1118 1071 +f 1120 1121 1122 +f 1120 1073 1072 +f 1120 1072 1121 +f 1121 1072 1123 +f 1074 1124 1072 +f 1072 1124 1123 +f 1075 1125 1074 +f 1074 1125 1124 +f 1125 1075 1076 +f 1126 1125 1076 +f 1068 1116 1077 +f 1116 1127 1077 +f 1071 1078 1119 +f 1119 1078 1128 +f 1129 1120 1122 +f 1130 1129 1122 +f 1073 1129 1079 +f 1120 1129 1073 +f 1076 1080 1126 +f 1126 1080 1131 +f 1077 1127 1081 +f 1127 1132 1081 +f 1078 1082 1128 +f 1128 1082 1133 +f 1134 1129 1130 +f 1135 1134 1130 +f 1079 1134 1083 +f 1129 1134 1079 +f 1080 1084 1131 +f 1131 1084 1136 +f 1081 1132 1137 +f 1085 1081 1137 +f 1086 1085 1138 +f 1085 1137 1138 +f 1087 1086 1139 +f 1086 1138 1139 +f 1133 1082 1087 +f 1139 1133 1087 +f 1134 1135 1140 +f 1083 1134 1140 +f 1083 1140 1088 +f 1088 1140 1141 +f 1089 1088 1142 +f 1088 1141 1142 +f 1090 1089 1143 +f 1089 1142 1143 +f 1136 1084 1090 +f 1143 1136 1090 +f 1091 1144 1145 +f 1092 1091 1145 +f 1093 1146 1091 +f 1091 1146 1144 +f 1094 1147 1093 +f 1093 1147 1146 +f 1147 1094 1095 +f 1148 1147 1095 +f 1149 1150 1151 +f 1149 1097 1096 +f 1149 1096 1150 +f 1150 1096 1152 +f 1098 1153 1096 +f 1096 1153 1152 +f 1099 1154 1098 +f 1098 1154 1153 +f 1154 1099 1100 +f 1155 1154 1100 +f 1092 1145 1101 +f 1145 1156 1101 +f 1095 1102 1148 +f 1148 1102 1157 +f 1158 1149 1151 +f 1159 1158 1151 +f 1097 1158 1103 +f 1149 1158 1097 +f 1100 1104 1155 +f 1155 1104 1160 +f 1101 1156 1105 +f 1156 1161 1105 +f 1102 1106 1157 +f 1157 1106 1162 +f 1163 1158 1159 +f 1164 1163 1159 +f 1103 1163 1107 +f 1158 1163 1103 +f 1104 1108 1160 +f 1160 1108 1165 +f 1105 1161 1166 +f 1109 1105 1166 +f 1110 1109 1167 +f 1109 1166 1167 +f 1111 1110 1168 +f 1110 1167 1168 +f 1162 1106 1111 +f 1168 1162 1111 +f 1163 1164 1169 +f 1107 1163 1169 +f 1107 1169 1112 +f 1112 1169 1170 +f 1113 1112 1171 +f 1112 1170 1171 +f 1114 1113 1172 +f 1113 1171 1172 +f 1165 1108 1114 +f 1172 1165 1114 +f 1115 1173 1174 +f 1116 1115 1174 +f 1117 1175 1115 +f 1115 1175 1173 +f 1118 1176 1117 +f 1117 1176 1175 +f 1119 1177 1178 +f 1119 1178 1118 +f 1118 1178 1176 +f 1178 1177 1179 +f 1121 1180 1181 +f 1122 1121 1181 +f 1123 1182 1121 +f 1121 1182 1180 +f 1124 1183 1123 +f 1123 1183 1182 +f 1125 1184 1124 +f 1124 1184 1183 +f 1184 1125 1126 +f 1185 1184 1126 +f 1116 1174 1127 +f 1174 1186 1127 +f 1177 1128 1187 +f 1119 1128 1177 +f 1188 1179 1177 +f 1187 1188 1177 +f 1122 1181 1130 +f 1181 1189 1130 +f 1126 1131 1185 +f 1185 1131 1190 +f 1127 1186 1132 +f 1186 1191 1132 +f 1187 1133 1192 +f 1128 1133 1187 +f 1193 1188 1187 +f 1192 1193 1187 +f 1130 1189 1135 +f 1189 1194 1135 +f 1131 1136 1190 +f 1190 1136 1195 +f 1132 1191 1196 +f 1137 1132 1196 +f 1138 1137 1197 +f 1137 1196 1197 +f 1139 1138 1198 +f 1138 1197 1198 +f 1192 1133 1139 +f 1192 1139 1199 +f 1199 1139 1198 +f 1193 1192 1199 +f 1135 1194 1200 +f 1140 1135 1200 +f 1141 1140 1201 +f 1140 1200 1201 +f 1142 1141 1202 +f 1141 1201 1202 +f 1143 1142 1203 +f 1142 1202 1203 +f 1195 1136 1143 +f 1203 1195 1143 +f 1144 1204 1205 +f 1145 1144 1205 +f 1146 1206 1144 +f 1144 1206 1204 +f 1147 1207 1146 +f 1146 1207 1206 +f 1148 1208 1209 +f 1148 1209 1147 +f 1147 1209 1207 +f 1209 1208 1210 +f 1150 1211 1212 +f 1151 1150 1212 +f 1152 1213 1150 +f 1150 1213 1211 +f 1153 1214 1152 +f 1152 1214 1213 +f 1154 1215 1153 +f 1153 1215 1214 +f 1215 1154 1155 +f 1216 1215 1155 +f 1145 1205 1156 +f 1205 1217 1156 +f 1208 1157 1218 +f 1148 1157 1208 +f 1219 1210 1208 +f 1218 1219 1208 +f 1151 1212 1159 +f 1212 1220 1159 +f 1155 1160 1216 +f 1216 1160 1221 +f 1156 1217 1161 +f 1217 1222 1161 +f 1218 1162 1223 +f 1157 1162 1218 +f 1224 1219 1218 +f 1223 1224 1218 +f 1159 1220 1164 +f 1220 1225 1164 +f 1160 1165 1221 +f 1221 1165 1226 +f 1161 1222 1227 +f 1166 1161 1227 +f 1167 1166 1228 +f 1166 1227 1228 +f 1168 1167 1229 +f 1167 1228 1229 +f 1223 1162 1168 +f 1223 1168 1230 +f 1230 1168 1229 +f 1224 1223 1230 +f 1164 1225 1231 +f 1169 1164 1231 +f 1170 1169 1232 +f 1169 1231 1232 +f 1171 1170 1233 +f 1170 1232 1233 +f 1172 1171 1234 +f 1171 1233 1234 +f 1226 1165 1172 +f 1234 1226 1172 +f 1173 1235 1236 +f 1174 1173 1236 +f 1175 1237 1173 +f 1173 1237 1235 +f 1176 1238 1175 +f 1175 1238 1237 +f 1178 1239 1176 +f 1176 1239 1238 +f 1179 1240 1241 +f 1179 1241 1178 +f 1178 1241 1239 +f 1241 1240 1242 +f 1243 1244 1245 +f 1243 1181 1180 +f 1243 1180 1244 +f 1244 1180 1246 +f 1182 1247 1180 +f 1180 1247 1246 +f 1183 1248 1182 +f 1182 1248 1247 +f 1184 1249 1183 +f 1183 1249 1248 +f 1249 1184 1185 +f 1250 1249 1185 +f 1174 1236 1186 +f 1236 1251 1186 +f 1240 1188 1252 +f 1179 1188 1240 +f 1253 1242 1240 +f 1252 1253 1240 +f 1254 1243 1245 +f 1255 1254 1245 +f 1181 1254 1189 +f 1243 1254 1181 +f 1185 1190 1250 +f 1250 1190 1256 +f 1186 1251 1191 +f 1251 1257 1191 +f 1252 1193 1258 +f 1188 1193 1252 +f 1259 1253 1252 +f 1258 1259 1252 +f 1260 1254 1255 +f 1261 1260 1255 +f 1189 1260 1194 +f 1254 1260 1189 +f 1190 1195 1256 +f 1256 1195 1262 +f 1263 1196 1191 +f 1263 1191 1264 +f 1264 1191 1257 +f 1196 1265 1197 +f 1263 1265 1196 +f 1197 1266 1198 +f 1265 1266 1197 +f 1198 1267 1199 +f 1266 1267 1198 +f 1199 1258 1193 +f 1199 1267 1258 +f 1267 1268 1258 +f 1269 1259 1258 +f 1268 1269 1258 +f 1270 1260 1261 +f 1271 1270 1261 +f 1194 1272 1200 +f 1194 1260 1272 +f 1260 1270 1272 +f 1200 1273 1201 +f 1272 1273 1200 +f 1201 1274 1202 +f 1273 1274 1201 +f 1202 1275 1203 +f 1274 1275 1202 +f 1203 1275 1276 +f 1203 1276 1195 +f 1195 1276 1262 +f 1263 1264 1277 +f 1265 1263 1277 +f 1278 1265 1277 +f 1266 1265 1278 +f 1279 1266 1278 +f 1267 1266 1279 +f 1280 1267 1279 +f 1268 1267 1280 +f 1281 1268 1280 +f 1269 1268 1281 +f 1270 1271 1282 +f 1272 1270 1282 +f 1283 1272 1282 +f 1273 1272 1283 +f 1284 1273 1283 +f 1274 1273 1284 +f 1285 1274 1284 +f 1275 1274 1285 +f 1286 1275 1285 +f 1276 1275 1286 +f 1287 1288 1289 +f 1287 1290 1291 +f 1288 1287 1291 +f 1290 1292 1293 +f 1291 1290 1293 +f 1292 1294 1295 +f 1293 1292 1295 +f 1294 1296 1297 +f 1295 1294 1297 +f 1297 1296 1298 +f 1299 1300 1301 +f 1299 1302 1303 +f 1300 1299 1303 +f 1302 1304 1305 +f 1303 1302 1305 +f 1304 1306 1307 +f 1305 1304 1307 +f 1306 1308 1309 +f 1307 1306 1309 +f 1309 1308 1310 +f 1204 1287 1289 +f 1204 1289 1205 +f 1205 1289 1311 +f 1206 1287 1204 +f 1290 1287 1206 +f 1207 1290 1206 +f 1292 1290 1207 +f 1209 1292 1207 +f 1294 1292 1209 +f 1210 1294 1209 +f 1210 1312 1294 +f 1312 1296 1294 +f 1313 1298 1296 +f 1312 1313 1296 +f 1314 1299 1301 +f 1315 1314 1301 +f 1211 1314 1212 +f 1211 1302 1314 +f 1302 1299 1314 +f 1213 1302 1211 +f 1304 1302 1213 +f 1214 1304 1213 +f 1306 1304 1214 +f 1215 1306 1214 +f 1308 1306 1215 +f 1308 1215 1216 +f 1308 1216 1310 +f 1310 1216 1316 +f 1205 1311 1217 +f 1311 1317 1217 +f 1312 1219 1318 +f 1210 1219 1312 +f 1319 1313 1312 +f 1318 1319 1312 +f 1320 1314 1315 +f 1321 1320 1315 +f 1212 1320 1220 +f 1314 1320 1212 +f 1216 1221 1316 +f 1316 1221 1322 +f 1217 1317 1222 +f 1317 1323 1222 +f 1318 1224 1324 +f 1219 1224 1318 +f 1325 1319 1318 +f 1324 1325 1318 +f 1326 1320 1321 +f 1327 1326 1321 +f 1220 1326 1225 +f 1320 1326 1220 +f 1221 1226 1322 +f 1322 1226 1328 +f 1222 1323 1329 +f 1227 1222 1329 +f 1228 1227 1330 +f 1227 1329 1330 +f 1229 1228 1331 +f 1228 1330 1331 +f 1230 1229 1332 +f 1229 1331 1332 +f 1324 1224 1230 +f 1324 1230 1333 +f 1333 1230 1332 +f 1325 1324 1333 +f 1326 1327 1334 +f 1225 1326 1334 +f 1225 1334 1231 +f 1231 1334 1335 +f 1232 1231 1336 +f 1231 1335 1336 +f 1233 1232 1337 +f 1232 1336 1337 +f 1234 1233 1338 +f 1233 1337 1338 +f 1328 1226 1234 +f 1338 1328 1234 +f 1235 1339 1340 +f 1236 1235 1340 +f 1237 1341 1235 +f 1235 1341 1339 +f 1238 1342 1237 +f 1237 1342 1341 +f 1239 1343 1238 +f 1238 1343 1342 +f 1241 1344 1239 +f 1239 1344 1343 +f 1242 1345 1346 +f 1242 1346 1241 +f 1241 1346 1344 +f 1345 1347 1348 +f 1346 1345 1348 +f 1347 1349 1350 +f 1348 1347 1350 +f 1349 1351 1352 +f 1350 1349 1352 +f 1351 1353 1354 +f 1352 1351 1354 +f 1353 1245 1244 +f 1353 1244 1354 +f 1354 1244 1355 +f 1246 1356 1244 +f 1244 1356 1355 +f 1247 1357 1246 +f 1246 1357 1356 +f 1248 1358 1247 +f 1247 1358 1357 +f 1249 1359 1248 +f 1248 1359 1358 +f 1359 1249 1250 +f 1360 1359 1250 +f 1236 1340 1251 +f 1340 1361 1251 +f 1345 1253 1362 +f 1242 1253 1345 +f 1347 1345 1363 +f 1363 1345 1362 +f 1349 1347 1364 +f 1364 1347 1363 +f 1351 1349 1365 +f 1365 1349 1364 +f 1353 1351 1366 +f 1366 1351 1365 +f 1245 1366 1255 +f 1353 1366 1245 +f 1250 1256 1360 +f 1360 1256 1367 +f 1251 1361 1257 +f 1361 1368 1257 +f 1362 1259 1369 +f 1253 1259 1362 +f 1363 1362 1370 +f 1370 1362 1369 +f 1364 1363 1371 +f 1371 1363 1370 +f 1365 1364 1372 +f 1372 1364 1371 +f 1366 1365 1373 +f 1373 1365 1372 +f 1255 1373 1261 +f 1366 1373 1255 +f 1256 1262 1367 +f 1367 1262 1374 +f 1257 1368 1264 +f 1368 1375 1264 +f 1369 1269 1376 +f 1259 1269 1369 +f 1370 1369 1377 +f 1377 1369 1376 +f 1371 1370 1378 +f 1378 1370 1377 +f 1372 1371 1379 +f 1379 1371 1378 +f 1373 1372 1380 +f 1380 1372 1379 +f 1261 1380 1271 +f 1373 1380 1261 +f 1262 1276 1374 +f 1374 1276 1381 +f 1382 1277 1264 +f 1382 1264 1383 +f 1383 1264 1375 +f 1277 1384 1278 +f 1382 1384 1277 +f 1278 1385 1279 +f 1384 1385 1278 +f 1279 1386 1280 +f 1385 1386 1279 +f 1280 1387 1281 +f 1386 1387 1280 +f 1281 1376 1269 +f 1281 1387 1376 +f 1387 1388 1376 +f 1377 1376 1389 +f 1389 1376 1388 +f 1378 1377 1390 +f 1390 1377 1389 +f 1379 1378 1391 +f 1391 1378 1390 +f 1380 1379 1392 +f 1392 1379 1391 +f 1271 1393 1282 +f 1271 1380 1393 +f 1380 1392 1393 +f 1282 1394 1283 +f 1393 1394 1282 +f 1283 1395 1284 +f 1394 1395 1283 +f 1284 1396 1285 +f 1395 1396 1284 +f 1285 1397 1286 +f 1396 1397 1285 +f 1286 1397 1398 +f 1286 1398 1276 +f 1276 1398 1381 +f 1399 1382 1383 +f 1400 1399 1383 +f 1384 1382 1401 +f 1401 1382 1399 +f 1385 1384 1402 +f 1402 1384 1401 +f 1386 1385 1403 +f 1403 1385 1402 +f 1387 1386 1404 +f 1404 1386 1403 +f 1388 1387 1405 +f 1405 1387 1404 +f 1389 1388 1406 +f 1406 1388 1405 +f 1390 1389 1407 +f 1407 1389 1406 +f 1391 1390 1408 +f 1408 1390 1407 +f 1392 1391 1409 +f 1409 1391 1408 +f 1393 1392 1410 +f 1410 1392 1409 +f 1394 1393 1411 +f 1411 1393 1410 +f 1395 1394 1412 +f 1412 1394 1411 +f 1396 1395 1413 +f 1413 1395 1412 +f 1397 1396 1414 +f 1414 1396 1413 +f 1415 1398 1397 +f 1414 1415 1397 +f 1416 1399 1400 +f 1417 1416 1400 +f 1401 1399 1418 +f 1418 1399 1416 +f 1402 1401 1419 +f 1419 1401 1418 +f 1403 1402 1420 +f 1420 1402 1419 +f 1404 1403 1421 +f 1421 1403 1420 +f 1405 1404 1422 +f 1422 1404 1421 +f 1406 1405 1423 +f 1423 1405 1422 +f 1407 1406 1424 +f 1424 1406 1423 +f 1408 1407 1425 +f 1425 1407 1424 +f 1409 1408 1426 +f 1426 1408 1425 +f 1410 1409 1427 +f 1427 1409 1426 +f 1411 1410 1428 +f 1428 1410 1427 +f 1412 1411 1429 +f 1429 1411 1428 +f 1413 1412 1430 +f 1430 1412 1429 +f 1414 1413 1431 +f 1431 1413 1430 +f 1432 1415 1414 +f 1431 1432 1414 +f 1433 1416 1417 +f 1434 1433 1417 +f 1418 1416 1435 +f 1435 1416 1433 +f 1419 1418 1436 +f 1436 1418 1435 +f 1420 1419 1437 +f 1437 1419 1436 +f 1421 1420 1438 +f 1438 1420 1437 +f 1422 1421 1439 +f 1439 1421 1438 +f 1423 1422 1440 +f 1440 1422 1439 +f 1424 1423 1441 +f 1441 1423 1440 +f 1425 1424 1442 +f 1442 1424 1441 +f 1426 1425 1443 +f 1443 1425 1442 +f 1427 1426 1444 +f 1444 1426 1443 +f 1428 1427 1445 +f 1445 1427 1444 +f 1429 1428 1446 +f 1446 1428 1445 +f 1430 1429 1447 +f 1447 1429 1446 +f 1431 1430 1448 +f 1448 1430 1447 +f 1449 1432 1431 +f 1448 1449 1431 +f 1450 1433 1434 +f 1451 1450 1434 +f 1435 1433 1452 +f 1452 1433 1450 +f 1436 1435 1453 +f 1453 1435 1452 +f 1437 1436 1454 +f 1454 1436 1453 +f 1438 1437 1455 +f 1455 1437 1454 +f 1439 1438 1456 +f 1456 1438 1455 +f 1440 1439 1457 +f 1457 1439 1456 +f 1441 1440 1458 +f 1458 1440 1457 +f 1442 1441 1459 +f 1459 1441 1458 +f 1443 1442 1460 +f 1460 1442 1459 +f 1444 1443 1461 +f 1461 1443 1460 +f 1445 1444 1462 +f 1462 1444 1461 +f 1446 1445 1463 +f 1463 1445 1462 +f 1447 1446 1464 +f 1464 1446 1463 +f 1448 1447 1465 +f 1465 1447 1464 +f 1466 1449 1448 +f 1465 1466 1448 +f 1467 1450 1451 +f 1468 1467 1451 +f 1452 1450 1469 +f 1469 1450 1467 +f 1453 1452 1470 +f 1470 1452 1469 +f 1454 1453 1471 +f 1471 1453 1470 +f 1455 1454 1472 +f 1472 1454 1471 +f 1456 1455 1473 +f 1473 1455 1472 +f 1457 1456 1474 +f 1474 1456 1473 +f 1458 1457 1475 +f 1475 1457 1474 +f 1459 1458 1476 +f 1476 1458 1475 +f 1460 1459 1477 +f 1477 1459 1476 +f 1461 1460 1478 +f 1478 1460 1477 +f 1462 1461 1479 +f 1479 1461 1478 +f 1463 1462 1480 +f 1480 1462 1479 +f 1464 1463 1481 +f 1481 1463 1480 +f 1465 1464 1482 +f 1482 1464 1481 +f 1483 1466 1465 +f 1482 1483 1465 +f 1288 1467 1468 +f 1288 1468 1289 +f 1289 1468 1484 +f 1291 1467 1288 +f 1469 1467 1291 +f 1293 1469 1291 +f 1470 1469 1293 +f 1295 1470 1293 +f 1471 1470 1295 +f 1297 1471 1295 +f 1472 1471 1297 +f 1298 1472 1297 +f 1298 1485 1472 +f 1485 1473 1472 +f 1474 1473 1486 +f 1486 1473 1485 +f 1475 1474 1487 +f 1487 1474 1486 +f 1476 1475 1488 +f 1488 1475 1487 +f 1477 1476 1489 +f 1489 1476 1488 +f 1300 1489 1301 +f 1300 1478 1489 +f 1478 1477 1489 +f 1303 1478 1300 +f 1479 1478 1303 +f 1305 1479 1303 +f 1480 1479 1305 +f 1307 1480 1305 +f 1481 1480 1307 +f 1309 1481 1307 +f 1482 1481 1309 +f 1482 1309 1310 +f 1482 1310 1483 +f 1483 1310 1490 +f 1289 1484 1311 +f 1484 1491 1311 +f 1485 1313 1492 +f 1298 1313 1485 +f 1486 1485 1493 +f 1493 1485 1492 +f 1487 1486 1494 +f 1494 1486 1493 +f 1488 1487 1495 +f 1495 1487 1494 +f 1489 1488 1496 +f 1496 1488 1495 +f 1301 1496 1315 +f 1489 1496 1301 +f 1310 1316 1490 +f 1490 1316 1497 +f 1311 1491 1317 +f 1491 1498 1317 +f 1492 1319 1499 +f 1313 1319 1492 +f 1493 1492 1500 +f 1500 1492 1499 +f 1494 1493 1501 +f 1501 1493 1500 +f 1495 1494 1502 +f 1502 1494 1501 +f 1496 1495 1503 +f 1503 1495 1502 +f 1315 1503 1321 +f 1496 1503 1315 +f 1316 1322 1497 +f 1497 1322 1504 +f 1317 1498 1323 +f 1498 1505 1323 +f 1499 1325 1506 +f 1319 1325 1499 +f 1500 1499 1507 +f 1507 1499 1506 +f 1501 1500 1508 +f 1508 1500 1507 +f 1502 1501 1509 +f 1509 1501 1508 +f 1503 1502 1510 +f 1510 1502 1509 +f 1321 1510 1327 +f 1503 1510 1321 +f 1322 1328 1504 +f 1504 1328 1511 +f 1323 1505 1512 +f 1329 1323 1512 +f 1330 1329 1513 +f 1329 1512 1513 +f 1331 1330 1514 +f 1330 1513 1514 +f 1332 1331 1515 +f 1331 1514 1515 +f 1333 1332 1516 +f 1332 1515 1516 +f 1506 1325 1333 +f 1506 1333 1517 +f 1517 1333 1516 +f 1507 1506 1517 +f 1518 1507 1517 +f 1508 1507 1518 +f 1519 1508 1518 +f 1509 1508 1519 +f 1520 1509 1519 +f 1510 1509 1520 +f 1521 1510 1520 +f 1327 1510 1521 +f 1327 1521 1334 +f 1334 1521 1522 +f 1335 1334 1523 +f 1334 1522 1523 +f 1336 1335 1524 +f 1335 1523 1524 +f 1337 1336 1525 +f 1336 1524 1525 +f 1338 1337 1526 +f 1337 1525 1526 +f 1511 1328 1338 +f 1526 1511 1338 +f 1339 1527 1528 +f 1340 1339 1528 +f 1341 1529 1339 +f 1339 1529 1527 +f 1342 1530 1341 +f 1341 1530 1529 +f 1343 1531 1342 +f 1342 1531 1530 +f 1344 1532 1343 +f 1343 1532 1531 +f 1346 1533 1344 +f 1344 1533 1532 +f 1348 1534 1346 +f 1346 1534 1533 +f 1350 1535 1348 +f 1348 1535 1534 +f 1352 1536 1350 +f 1350 1536 1535 +f 1354 1537 1352 +f 1352 1537 1536 +f 1355 1538 1354 +f 1354 1538 1537 +f 1356 1539 1355 +f 1355 1539 1538 +f 1357 1540 1356 +f 1356 1540 1539 +f 1358 1541 1357 +f 1357 1541 1540 +f 1359 1542 1358 +f 1358 1542 1541 +f 1542 1359 1360 +f 1543 1542 1360 +f 1340 1528 1361 +f 1528 1544 1361 +f 1360 1367 1543 +f 1543 1367 1545 +f 1361 1544 1368 +f 1544 1546 1368 +f 1367 1374 1545 +f 1545 1374 1547 +f 1368 1546 1375 +f 1546 1548 1375 +f 1374 1381 1547 +f 1547 1381 1549 +f 1375 1548 1383 +f 1548 1550 1383 +f 1381 1398 1549 +f 1549 1398 1551 +f 1383 1550 1400 +f 1550 1552 1400 +f 1398 1415 1551 +f 1551 1415 1553 +f 1400 1552 1417 +f 1552 1554 1417 +f 1415 1432 1553 +f 1553 1432 1555 +f 1417 1554 1434 +f 1554 1556 1434 +f 1432 1449 1555 +f 1555 1449 1557 +f 1434 1556 1451 +f 1556 1558 1451 +f 1449 1466 1557 +f 1557 1466 1559 +f 1451 1558 1468 +f 1558 1560 1468 +f 1466 1483 1559 +f 1559 1483 1561 +f 1468 1560 1484 +f 1560 1562 1484 +f 1483 1490 1561 +f 1561 1490 1563 +f 1484 1562 1491 +f 1562 1564 1491 +f 1490 1497 1563 +f 1563 1497 1565 +f 1491 1564 1498 +f 1564 1566 1498 +f 1497 1504 1565 +f 1565 1504 1567 +f 1498 1566 1505 +f 1566 1568 1505 +f 1504 1511 1567 +f 1567 1511 1569 +f 1505 1568 1570 +f 1512 1505 1570 +f 1513 1512 1571 +f 1512 1570 1571 +f 1514 1513 1572 +f 1513 1571 1572 +f 1515 1514 1573 +f 1514 1572 1573 +f 1516 1515 1574 +f 1515 1573 1574 +f 1517 1516 1575 +f 1516 1574 1575 +f 1518 1517 1576 +f 1517 1575 1576 +f 1519 1518 1577 +f 1518 1576 1577 +f 1520 1519 1578 +f 1519 1577 1578 +f 1521 1520 1579 +f 1520 1578 1579 +f 1522 1521 1580 +f 1521 1579 1580 +f 1523 1522 1581 +f 1522 1580 1581 +f 1524 1523 1582 +f 1523 1581 1582 +f 1525 1524 1583 +f 1524 1582 1583 +f 1526 1525 1584 +f 1525 1583 1584 +f 1569 1511 1526 +f 1584 1569 1526 +f 1527 1585 1586 +f 1528 1527 1586 +f 1529 1587 1527 +f 1527 1587 1585 +f 1530 1588 1529 +f 1529 1588 1587 +f 1531 1589 1530 +f 1530 1589 1588 +f 1532 1590 1531 +f 1531 1590 1589 +f 1533 1591 1532 +f 1532 1591 1590 +f 1534 1592 1533 +f 1533 1592 1591 +f 1535 1593 1534 +f 1534 1593 1592 +f 1536 1594 1535 +f 1535 1594 1593 +f 1537 1595 1536 +f 1536 1595 1594 +f 1538 1596 1537 +f 1537 1596 1595 +f 1539 1597 1538 +f 1538 1597 1596 +f 1540 1598 1539 +f 1539 1598 1597 +f 1541 1599 1540 +f 1540 1599 1598 +f 1542 1600 1541 +f 1541 1600 1599 +f 1600 1542 1543 +f 1601 1600 1543 +f 1528 1586 1544 +f 1586 1602 1544 +f 1543 1545 1601 +f 1601 1545 1603 +f 1544 1602 1546 +f 1602 1604 1546 +f 1545 1547 1603 +f 1603 1547 1605 +f 1546 1604 1548 +f 1604 1606 1548 +f 1547 1549 1605 +f 1605 1549 1607 +f 1548 1606 1550 +f 1606 1608 1550 +f 1549 1551 1607 +f 1607 1551 1609 +f 1550 1608 1552 +f 1608 1610 1552 +f 1551 1553 1609 +f 1609 1553 1611 +f 1552 1610 1554 +f 1610 1612 1554 +f 1553 1555 1611 +f 1611 1555 1613 +f 1554 1612 1556 +f 1612 1614 1556 +f 1555 1557 1613 +f 1613 1557 1615 +f 1556 1614 1558 +f 1614 1616 1558 +f 1557 1559 1615 +f 1615 1559 1617 +f 1558 1616 1560 +f 1616 1618 1560 +f 1559 1561 1617 +f 1617 1561 1619 +f 1560 1618 1562 +f 1618 1620 1562 +f 1561 1563 1619 +f 1619 1563 1621 +f 1562 1620 1564 +f 1620 1622 1564 +f 1563 1565 1621 +f 1621 1565 1623 +f 1564 1622 1566 +f 1622 1624 1566 +f 1565 1567 1623 +f 1623 1567 1625 +f 1566 1624 1568 +f 1624 1626 1568 +f 1567 1569 1625 +f 1625 1569 1627 +f 1568 1626 1628 +f 1570 1568 1628 +f 1571 1570 1629 +f 1570 1628 1629 +f 1572 1571 1630 +f 1571 1629 1630 +f 1573 1572 1631 +f 1572 1630 1631 +f 1574 1573 1632 +f 1573 1631 1632 +f 1575 1574 1633 +f 1574 1632 1633 +f 1576 1575 1634 +f 1575 1633 1634 +f 1577 1576 1635 +f 1576 1634 1635 +f 1578 1577 1636 +f 1577 1635 1636 +f 1579 1578 1637 +f 1578 1636 1637 +f 1580 1579 1638 +f 1579 1637 1638 +f 1581 1580 1639 +f 1580 1638 1639 +f 1582 1581 1640 +f 1581 1639 1640 +f 1583 1582 1641 +f 1582 1640 1641 +f 1584 1583 1642 +f 1583 1641 1642 +f 1627 1569 1584 +f 1642 1627 1584 +f 1585 1643 1586 +f 1585 1587 1644 +f 1643 1585 1644 +f 1587 1588 1645 +f 1644 1587 1645 +f 1588 1589 1646 +f 1645 1588 1646 +f 1589 1590 1647 +f 1646 1589 1647 +f 1590 1591 1648 +f 1647 1590 1648 +f 1591 1592 1649 +f 1648 1591 1649 +f 1592 1593 1650 +f 1649 1592 1650 +f 1593 1594 1651 +f 1650 1593 1651 +f 1594 1595 1652 +f 1651 1594 1652 +f 1595 1596 1653 +f 1652 1595 1653 +f 1596 1597 1654 +f 1653 1596 1654 +f 1597 1598 1655 +f 1654 1597 1655 +f 1598 1599 1656 +f 1655 1598 1656 +f 1599 1600 1657 +f 1656 1599 1657 +f 1600 1601 1657 +f 1643 1658 1602 +f 1586 1643 1602 +f 1644 1659 1643 +f 1659 1658 1643 +f 1645 1660 1644 +f 1660 1659 1644 +f 1646 1661 1645 +f 1661 1660 1645 +f 1647 1662 1646 +f 1662 1661 1646 +f 1648 1663 1647 +f 1663 1662 1647 +f 1649 1664 1648 +f 1664 1663 1648 +f 1650 1665 1649 +f 1665 1664 1649 +f 1651 1666 1650 +f 1666 1665 1650 +f 1652 1667 1651 +f 1667 1666 1651 +f 1653 1668 1652 +f 1668 1667 1652 +f 1654 1669 1653 +f 1669 1668 1653 +f 1655 1670 1654 +f 1670 1669 1654 +f 1656 1671 1655 +f 1671 1670 1655 +f 1657 1672 1656 +f 1672 1671 1656 +f 1601 1603 1672 +f 1657 1601 1672 +f 1658 1673 1604 +f 1602 1658 1604 +f 1659 1674 1658 +f 1674 1673 1658 +f 1660 1675 1659 +f 1675 1674 1659 +f 1661 1676 1660 +f 1676 1675 1660 +f 1662 1677 1661 +f 1677 1676 1661 +f 1678 1663 1679 +f 1678 1677 1663 +f 1677 1662 1663 +f 1664 1679 1663 +f 1680 1679 1664 +f 1665 1680 1664 +f 1681 1680 1665 +f 1666 1681 1665 +f 1682 1681 1666 +f 1667 1682 1666 +f 1683 1682 1667 +f 1683 1684 1685 +f 1683 1667 1684 +f 1667 1668 1684 +f 1669 1686 1668 +f 1686 1684 1668 +f 1670 1687 1669 +f 1687 1686 1669 +f 1671 1688 1670 +f 1688 1687 1670 +f 1672 1689 1671 +f 1689 1688 1671 +f 1603 1605 1689 +f 1672 1603 1689 +f 1673 1690 1606 +f 1604 1673 1606 +f 1674 1691 1673 +f 1691 1690 1673 +f 1675 1692 1674 +f 1692 1691 1674 +f 1676 1693 1675 +f 1693 1692 1675 +f 1694 1677 1695 +f 1694 1693 1677 +f 1693 1676 1677 +f 1678 1695 1677 +f 1684 1696 1685 +f 1696 1697 1698 +f 1696 1684 1697 +f 1684 1686 1697 +f 1687 1699 1686 +f 1699 1697 1686 +f 1688 1700 1687 +f 1700 1699 1687 +f 1689 1701 1688 +f 1701 1700 1688 +f 1605 1607 1701 +f 1689 1605 1701 +f 1690 1702 1608 +f 1606 1690 1608 +f 1691 1703 1690 +f 1703 1702 1690 +f 1692 1704 1691 +f 1704 1703 1691 +f 1705 1693 1706 +f 1705 1704 1693 +f 1704 1692 1693 +f 1694 1706 1693 +f 1697 1707 1698 +f 1707 1708 1709 +f 1707 1697 1708 +f 1697 1699 1708 +f 1700 1710 1699 +f 1710 1708 1699 +f 1701 1711 1700 +f 1711 1710 1700 +f 1607 1609 1711 +f 1701 1607 1711 +f 1702 1712 1610 +f 1608 1702 1610 +f 1703 1713 1702 +f 1713 1712 1702 +f 1714 1704 1715 +f 1714 1713 1704 +f 1713 1703 1704 +f 1705 1715 1704 +f 1716 1709 1708 +f 1717 1709 1716 +f 1710 1718 1708 +f 1718 1716 1708 +f 1711 1719 1710 +f 1719 1718 1710 +f 1609 1611 1719 +f 1711 1609 1719 +f 1712 1720 1612 +f 1610 1712 1612 +f 1713 1721 1712 +f 1721 1720 1712 +f 1722 1713 1714 +f 1721 1713 1722 +f 1723 1717 1716 +f 1724 1717 1723 +f 1718 1725 1716 +f 1725 1723 1716 +f 1719 1726 1718 +f 1726 1725 1718 +f 1611 1613 1726 +f 1719 1611 1726 +f 1720 1727 1614 +f 1612 1720 1614 +f 1721 1728 1720 +f 1728 1727 1720 +f 1729 1721 1722 +f 1728 1721 1729 +f 1730 1724 1723 +f 1731 1724 1730 +f 1725 1732 1723 +f 1732 1730 1723 +f 1726 1733 1725 +f 1733 1732 1725 +f 1613 1615 1733 +f 1726 1613 1733 +f 1727 1734 1616 +f 1614 1727 1616 +f 1728 1735 1727 +f 1735 1734 1727 +f 1736 1728 1729 +f 1735 1728 1736 +f 1737 1731 1730 +f 1738 1731 1737 +f 1732 1739 1730 +f 1739 1737 1730 +f 1733 1740 1732 +f 1740 1739 1732 +f 1615 1617 1740 +f 1733 1615 1740 +f 1734 1741 1618 +f 1616 1734 1618 +f 1735 1742 1734 +f 1742 1741 1734 +f 1743 1735 1736 +f 1743 1744 1735 +f 1744 1742 1735 +f 1743 1745 1744 +f 1746 1738 1737 +f 1747 1738 1746 +f 1739 1748 1737 +f 1748 1746 1737 +f 1740 1749 1739 +f 1749 1748 1739 +f 1617 1619 1749 +f 1740 1617 1749 +f 1741 1750 1620 +f 1618 1741 1620 +f 1742 1751 1741 +f 1751 1750 1741 +f 1744 1752 1742 +f 1752 1751 1742 +f 1753 1744 1745 +f 1753 1754 1744 +f 1754 1752 1744 +f 1753 1755 1754 +f 1756 1757 1758 +f 1747 1756 1758 +f 1747 1746 1756 +f 1746 1759 1756 +f 1748 1760 1746 +f 1760 1759 1746 +f 1749 1761 1748 +f 1761 1760 1748 +f 1619 1621 1761 +f 1749 1619 1761 +f 1750 1762 1622 +f 1620 1750 1622 +f 1751 1763 1750 +f 1763 1762 1750 +f 1752 1764 1751 +f 1764 1763 1751 +f 1754 1765 1752 +f 1765 1764 1752 +f 1766 1754 1755 +f 1766 1767 1754 +f 1767 1765 1754 +f 1766 1768 1767 +f 1769 1770 1771 +f 1757 1769 1771 +f 1757 1756 1769 +f 1756 1772 1769 +f 1759 1773 1756 +f 1773 1772 1756 +f 1760 1774 1759 +f 1774 1773 1759 +f 1761 1775 1760 +f 1775 1774 1760 +f 1621 1623 1775 +f 1761 1621 1775 +f 1762 1776 1624 +f 1622 1762 1624 +f 1763 1777 1762 +f 1777 1776 1762 +f 1764 1778 1763 +f 1778 1777 1763 +f 1765 1779 1764 +f 1779 1778 1764 +f 1767 1780 1765 +f 1780 1779 1765 +f 1781 1767 1768 +f 1781 1782 1767 +f 1782 1780 1767 +f 1782 1783 1784 +f 1781 1783 1782 +f 1784 1785 1786 +f 1783 1785 1784 +f 1786 1787 1788 +f 1785 1787 1786 +f 1788 1789 1790 +f 1787 1789 1788 +f 1770 1790 1789 +f 1770 1769 1790 +f 1769 1791 1790 +f 1772 1792 1769 +f 1792 1791 1769 +f 1773 1793 1772 +f 1793 1792 1772 +f 1774 1794 1773 +f 1794 1793 1773 +f 1775 1795 1774 +f 1795 1794 1774 +f 1623 1625 1795 +f 1775 1623 1795 +f 1776 1796 1626 +f 1624 1776 1626 +f 1777 1797 1776 +f 1797 1796 1776 +f 1778 1798 1777 +f 1798 1797 1777 +f 1779 1799 1778 +f 1799 1798 1778 +f 1780 1800 1779 +f 1800 1799 1779 +f 1782 1801 1780 +f 1801 1800 1780 +f 1784 1802 1782 +f 1802 1801 1782 +f 1786 1803 1784 +f 1803 1802 1784 +f 1788 1804 1786 +f 1804 1803 1786 +f 1790 1805 1788 +f 1805 1804 1788 +f 1791 1806 1790 +f 1806 1805 1790 +f 1792 1807 1791 +f 1807 1806 1791 +f 1793 1808 1792 +f 1808 1807 1792 +f 1794 1809 1793 +f 1809 1808 1793 +f 1795 1810 1794 +f 1810 1809 1794 +f 1625 1627 1810 +f 1795 1625 1810 +f 1626 1796 1628 +f 1629 1628 1796 +f 1797 1629 1796 +f 1630 1629 1797 +f 1798 1630 1797 +f 1631 1630 1798 +f 1799 1631 1798 +f 1632 1631 1799 +f 1800 1632 1799 +f 1633 1632 1800 +f 1801 1633 1800 +f 1634 1633 1801 +f 1802 1634 1801 +f 1635 1634 1802 +f 1803 1635 1802 +f 1636 1635 1803 +f 1804 1636 1803 +f 1637 1636 1804 +f 1805 1637 1804 +f 1638 1637 1805 +f 1806 1638 1805 +f 1639 1638 1806 +f 1807 1639 1806 +f 1640 1639 1807 +f 1808 1640 1807 +f 1641 1640 1808 +f 1809 1641 1808 +f 1642 1641 1809 +f 1810 1642 1809 +f 1627 1642 1810 +f 1679 1811 1812 +f 1678 1679 1812 +f 1680 1813 1679 +f 1679 1813 1811 +f 1681 1814 1680 +f 1680 1814 1813 +f 1682 1815 1681 +f 1681 1815 1814 +f 1683 1816 1682 +f 1682 1816 1815 +f 1816 1683 1685 +f 1817 1816 1685 +f 1695 1818 1819 +f 1694 1695 1819 +f 1812 1695 1678 +f 1818 1695 1812 +f 1685 1820 1817 +f 1696 1820 1685 +f 1820 1696 1698 +f 1821 1820 1698 +f 1706 1822 1823 +f 1705 1706 1823 +f 1819 1706 1694 +f 1822 1706 1819 +f 1698 1824 1821 +f 1707 1824 1698 +f 1824 1707 1709 +f 1825 1824 1709 +f 1715 1826 1827 +f 1714 1715 1827 +f 1823 1715 1705 +f 1826 1715 1823 +f 1709 1717 1825 +f 1825 1717 1828 +f 1714 1827 1722 +f 1827 1829 1722 +f 1717 1724 1828 +f 1828 1724 1830 +f 1722 1829 1729 +f 1829 1831 1729 +f 1724 1731 1830 +f 1830 1731 1832 +f 1729 1831 1736 +f 1831 1833 1736 +f 1731 1738 1832 +f 1832 1738 1834 +f 1736 1833 1835 +f 1743 1736 1835 +f 1835 1745 1743 +f 1836 1745 1835 +f 1738 1747 1834 +f 1834 1747 1837 +f 1745 1836 1838 +f 1753 1745 1838 +f 1838 1755 1753 +f 1839 1755 1838 +f 1758 1840 1841 +f 1757 1840 1758 +f 1837 1747 1758 +f 1841 1837 1758 +f 1755 1839 1842 +f 1766 1755 1842 +f 1842 1768 1766 +f 1843 1768 1842 +f 1771 1844 1845 +f 1770 1844 1771 +f 1840 1757 1771 +f 1845 1840 1771 +f 1768 1843 1846 +f 1781 1768 1846 +f 1783 1781 1847 +f 1781 1846 1847 +f 1785 1783 1848 +f 1783 1847 1848 +f 1787 1785 1849 +f 1785 1848 1849 +f 1789 1787 1850 +f 1787 1849 1850 +f 1844 1770 1789 +f 1850 1844 1789 +f 1811 1851 1852 +f 1812 1811 1852 +f 1813 1853 1811 +f 1811 1853 1851 +f 1814 1854 1813 +f 1813 1854 1853 +f 1815 1855 1814 +f 1814 1855 1854 +f 1816 1856 1815 +f 1815 1856 1855 +f 1856 1816 1817 +f 1857 1856 1817 +f 1818 1858 1859 +f 1819 1818 1859 +f 1852 1818 1812 +f 1858 1818 1852 +f 1817 1860 1857 +f 1820 1860 1817 +f 1860 1820 1821 +f 1861 1860 1821 +f 1822 1862 1863 +f 1823 1822 1863 +f 1859 1822 1819 +f 1862 1822 1859 +f 1821 1864 1861 +f 1824 1864 1821 +f 1864 1824 1825 +f 1865 1864 1825 +f 1826 1866 1867 +f 1827 1826 1867 +f 1863 1826 1823 +f 1866 1826 1863 +f 1825 1828 1865 +f 1865 1828 1868 +f 1827 1867 1829 +f 1867 1869 1829 +f 1828 1830 1868 +f 1868 1830 1870 +f 1829 1869 1831 +f 1869 1871 1831 +f 1830 1832 1870 +f 1870 1832 1872 +f 1831 1871 1833 +f 1871 1873 1833 +f 1832 1834 1872 +f 1872 1834 1874 +f 1833 1873 1875 +f 1835 1833 1875 +f 1875 1836 1835 +f 1876 1836 1875 +f 1834 1837 1874 +f 1874 1837 1877 +f 1836 1876 1878 +f 1838 1836 1878 +f 1878 1839 1838 +f 1879 1839 1878 +f 1841 1880 1881 +f 1840 1880 1841 +f 1877 1837 1841 +f 1881 1877 1841 +f 1839 1879 1882 +f 1842 1839 1882 +f 1882 1843 1842 +f 1883 1843 1882 +f 1845 1884 1885 +f 1844 1884 1845 +f 1880 1840 1845 +f 1885 1880 1845 +f 1843 1883 1886 +f 1846 1843 1886 +f 1847 1846 1887 +f 1846 1886 1887 +f 1848 1847 1888 +f 1847 1887 1888 +f 1849 1848 1889 +f 1848 1888 1889 +f 1850 1849 1890 +f 1849 1889 1890 +f 1884 1844 1850 +f 1890 1884 1850 +f 1851 1891 1892 +f 1852 1851 1892 +f 1853 1893 1851 +f 1851 1893 1891 +f 1854 1894 1853 +f 1853 1894 1893 +f 1855 1895 1854 +f 1854 1895 1894 +f 1856 1896 1855 +f 1855 1896 1895 +f 1896 1856 1857 +f 1897 1896 1857 +f 1858 1898 1899 +f 1859 1858 1899 +f 1892 1858 1852 +f 1898 1858 1892 +f 1857 1900 1897 +f 1860 1900 1857 +f 1900 1860 1861 +f 1901 1900 1861 +f 1862 1902 1903 +f 1863 1862 1903 +f 1899 1862 1859 +f 1902 1862 1899 +f 1861 1904 1901 +f 1864 1904 1861 +f 1904 1864 1865 +f 1905 1904 1865 +f 1866 1906 1907 +f 1867 1866 1907 +f 1903 1866 1863 +f 1906 1866 1903 +f 1865 1868 1905 +f 1905 1868 1908 +f 1867 1907 1869 +f 1907 1909 1869 +f 1868 1870 1908 +f 1908 1870 1910 +f 1869 1909 1871 +f 1909 1911 1871 +f 1870 1872 1910 +f 1910 1872 1912 +f 1871 1911 1873 +f 1911 1913 1873 +f 1872 1874 1912 +f 1912 1874 1914 +f 1873 1913 1915 +f 1875 1873 1915 +f 1915 1876 1875 +f 1916 1876 1915 +f 1874 1877 1914 +f 1914 1877 1917 +f 1876 1916 1918 +f 1878 1876 1918 +f 1918 1879 1878 +f 1919 1879 1918 +f 1881 1920 1921 +f 1880 1920 1881 +f 1917 1877 1881 +f 1921 1917 1881 +f 1879 1919 1922 +f 1882 1879 1922 +f 1922 1883 1882 +f 1923 1883 1922 +f 1885 1924 1925 +f 1884 1924 1885 +f 1920 1880 1885 +f 1925 1920 1885 +f 1883 1923 1926 +f 1886 1883 1926 +f 1887 1886 1927 +f 1886 1926 1927 +f 1888 1887 1928 +f 1887 1927 1928 +f 1889 1888 1929 +f 1888 1928 1929 +f 1890 1889 1930 +f 1889 1929 1930 +f 1924 1884 1890 +f 1930 1924 1890 +f 1891 1931 1932 +f 1892 1891 1932 +f 1893 1933 1891 +f 1891 1933 1931 +f 1894 1934 1893 +f 1893 1934 1933 +f 1895 1935 1894 +f 1894 1935 1934 +f 1896 1936 1895 +f 1895 1936 1935 +f 1936 1896 1897 +f 1937 1936 1897 +f 1898 1938 1939 +f 1899 1898 1939 +f 1932 1898 1892 +f 1938 1898 1932 +f 1897 1940 1937 +f 1900 1940 1897 +f 1940 1900 1901 +f 1941 1940 1901 +f 1902 1942 1943 +f 1903 1902 1943 +f 1939 1902 1899 +f 1942 1902 1939 +f 1901 1944 1941 +f 1904 1944 1901 +f 1944 1904 1905 +f 1945 1944 1905 +f 1906 1946 1947 +f 1907 1906 1947 +f 1943 1906 1903 +f 1946 1906 1943 +f 1905 1908 1945 +f 1945 1908 1948 +f 1907 1947 1909 +f 1947 1949 1909 +f 1908 1910 1948 +f 1948 1910 1950 +f 1909 1949 1911 +f 1949 1951 1911 +f 1910 1912 1950 +f 1950 1912 1952 +f 1911 1951 1913 +f 1951 1953 1913 +f 1912 1914 1952 +f 1952 1914 1954 +f 1913 1953 1955 +f 1915 1913 1955 +f 1955 1916 1915 +f 1956 1916 1955 +f 1914 1917 1954 +f 1954 1917 1957 +f 1916 1956 1958 +f 1918 1916 1958 +f 1958 1919 1918 +f 1959 1919 1958 +f 1921 1960 1961 +f 1920 1960 1921 +f 1957 1917 1921 +f 1961 1957 1921 +f 1919 1959 1962 +f 1922 1919 1962 +f 1962 1923 1922 +f 1963 1923 1962 +f 1925 1964 1965 +f 1924 1964 1925 +f 1960 1920 1925 +f 1965 1960 1925 +f 1923 1963 1966 +f 1926 1923 1966 +f 1927 1926 1967 +f 1926 1966 1967 +f 1928 1927 1968 +f 1927 1967 1968 +f 1929 1928 1969 +f 1928 1968 1969 +f 1930 1929 1970 +f 1929 1969 1970 +f 1964 1924 1930 +f 1970 1964 1930 +f 1931 1971 1972 +f 1932 1931 1972 +f 1933 1973 1931 +f 1931 1973 1971 +f 1934 1974 1933 +f 1933 1974 1973 +f 1935 1975 1934 +f 1934 1975 1974 +f 1936 1976 1935 +f 1935 1976 1975 +f 1976 1936 1937 +f 1977 1976 1937 +f 1938 1978 1979 +f 1939 1938 1979 +f 1972 1938 1932 +f 1978 1938 1972 +f 1937 1980 1977 +f 1940 1980 1937 +f 1980 1940 1941 +f 1981 1980 1941 +f 1942 1982 1983 +f 1943 1942 1983 +f 1979 1942 1939 +f 1982 1942 1979 +f 1941 1984 1981 +f 1944 1984 1941 +f 1984 1944 1945 +f 1985 1984 1945 +f 1946 1986 1987 +f 1947 1946 1987 +f 1983 1946 1943 +f 1986 1946 1983 +f 1945 1948 1985 +f 1985 1948 1988 +f 1947 1987 1949 +f 1987 1989 1949 +f 1948 1950 1988 +f 1988 1950 1990 +f 1949 1989 1951 +f 1989 1991 1951 +f 1950 1952 1990 +f 1990 1952 1992 +f 1951 1991 1953 +f 1991 1993 1953 +f 1952 1954 1992 +f 1992 1954 1994 +f 1953 1993 1995 +f 1955 1953 1995 +f 1995 1956 1955 +f 1996 1956 1995 +f 1954 1957 1994 +f 1994 1957 1997 +f 1956 1996 1998 +f 1958 1956 1998 +f 1998 1959 1958 +f 1999 1959 1998 +f 1961 2000 2001 +f 1960 2000 1961 +f 1997 1957 1961 +f 2001 1997 1961 +f 1959 1999 2002 +f 1962 1959 2002 +f 2002 1963 1962 +f 2003 1963 2002 +f 1965 2004 2005 +f 1964 2004 1965 +f 2000 1960 1965 +f 2005 2000 1965 +f 1963 2003 2006 +f 1966 1963 2006 +f 1967 1966 2007 +f 1966 2006 2007 +f 1968 1967 2008 +f 1967 2007 2008 +f 1969 1968 2009 +f 1968 2008 2009 +f 1970 1969 2010 +f 1969 2009 2010 +f 2004 1964 1970 +f 2010 2004 1970 +f 1971 2011 2012 +f 1972 1971 2012 +f 1973 2013 1971 +f 1971 2013 2011 +f 1974 2014 1973 +f 1973 2014 2013 +f 1975 2015 1974 +f 1974 2015 2014 +f 1976 2016 1975 +f 1975 2016 2015 +f 2016 1976 1977 +f 2017 2016 1977 +f 1978 2018 2019 +f 1979 1978 2019 +f 2012 1978 1972 +f 2018 1978 2012 +f 1977 2020 2017 +f 1980 2020 1977 +f 2020 1980 1981 +f 2021 2020 1981 +f 1982 2022 2023 +f 1983 1982 2023 +f 2019 1982 1979 +f 2022 1982 2019 +f 1981 2024 2021 +f 1984 2024 1981 +f 2024 1984 1985 +f 2025 2024 1985 +f 1986 2026 2027 +f 1987 1986 2027 +f 2023 1986 1983 +f 2026 1986 2023 +f 1985 1988 2025 +f 2025 1988 2028 +f 1987 2027 1989 +f 2027 2029 1989 +f 1988 1990 2028 +f 2028 1990 2030 +f 1989 2029 1991 +f 2029 2031 1991 +f 1990 1992 2030 +f 2030 1992 2032 +f 1991 2031 1993 +f 2031 2033 1993 +f 1992 1994 2032 +f 2032 1994 2034 +f 1993 2033 2035 +f 1995 1993 2035 +f 2035 1996 1995 +f 2036 1996 2035 +f 1994 1997 2034 +f 2034 1997 2037 +f 1996 2036 2038 +f 1998 1996 2038 +f 2038 1999 1998 +f 2039 1999 2038 +f 2001 2040 2041 +f 2000 2040 2001 +f 2037 1997 2001 +f 2041 2037 2001 +f 1999 2039 2042 +f 2002 1999 2042 +f 2042 2003 2002 +f 2043 2003 2042 +f 2005 2044 2045 +f 2004 2044 2005 +f 2040 2000 2005 +f 2045 2040 2005 +f 2003 2043 2046 +f 2006 2003 2046 +f 2007 2006 2047 +f 2006 2046 2047 +f 2008 2007 2048 +f 2007 2047 2048 +f 2009 2008 2049 +f 2008 2048 2049 +f 2010 2009 2050 +f 2009 2049 2050 +f 2044 2004 2010 +f 2050 2044 2010 +f 2011 2051 2012 +f 2011 2013 2052 +f 2051 2011 2052 +f 2013 2014 2053 +f 2052 2013 2053 +f 2014 2015 2054 +f 2053 2014 2054 +f 2015 2016 2055 +f 2054 2015 2055 +f 2016 2017 2055 +f 2018 2056 2019 +f 2018 2012 2051 +f 2018 2051 2056 +f 2056 2051 2057 +f 2052 2058 2051 +f 2058 2057 2051 +f 2053 2059 2052 +f 2059 2058 2052 +f 2054 2060 2053 +f 2060 2059 2053 +f 2055 2061 2054 +f 2061 2060 2054 +f 2017 2020 2062 +f 2017 2062 2055 +f 2055 2062 2061 +f 2020 2021 2062 +f 2022 2063 2023 +f 2022 2019 2056 +f 2022 2056 2063 +f 2063 2056 2064 +f 2057 2065 2056 +f 2065 2064 2056 +f 2058 2066 2057 +f 2066 2065 2057 +f 2059 2067 2058 +f 2067 2066 2058 +f 2060 2068 2059 +f 2068 2067 2059 +f 2061 2069 2060 +f 2069 2068 2060 +f 2062 2070 2061 +f 2070 2069 2061 +f 2021 2024 2071 +f 2021 2071 2062 +f 2062 2071 2070 +f 2024 2025 2071 +f 2026 2072 2027 +f 2026 2023 2063 +f 2026 2063 2072 +f 2072 2063 2073 +f 2064 2074 2063 +f 2074 2073 2063 +f 2065 2075 2064 +f 2075 2074 2064 +f 2066 2076 2065 +f 2076 2075 2065 +f 2067 2077 2066 +f 2077 2076 2066 +f 2068 2078 2067 +f 2078 2077 2067 +f 2069 2079 2068 +f 2079 2078 2068 +f 2070 2080 2069 +f 2080 2079 2069 +f 2071 2081 2070 +f 2081 2080 2070 +f 2025 2028 2081 +f 2071 2025 2081 +f 2072 2082 2029 +f 2027 2072 2029 +f 2073 2083 2072 +f 2083 2082 2072 +f 2074 2084 2073 +f 2084 2083 2073 +f 2075 2085 2074 +f 2085 2084 2074 +f 2076 2086 2075 +f 2086 2085 2075 +f 2077 2087 2076 +f 2087 2086 2076 +f 2078 2088 2077 +f 2088 2087 2077 +f 2079 2089 2078 +f 2089 2088 2078 +f 2080 2090 2079 +f 2090 2089 2079 +f 2081 2091 2080 +f 2091 2090 2080 +f 2028 2030 2091 +f 2081 2028 2091 +f 2082 2092 2031 +f 2029 2082 2031 +f 2083 2093 2082 +f 2093 2092 2082 +f 2084 2094 2083 +f 2094 2093 2083 +f 2085 2095 2084 +f 2095 2094 2084 +f 2086 2096 2085 +f 2096 2095 2085 +f 2087 2097 2086 +f 2097 2096 2086 +f 2088 2098 2087 +f 2098 2097 2087 +f 2089 2099 2088 +f 2099 2098 2088 +f 2090 2100 2089 +f 2100 2099 2089 +f 2091 2101 2090 +f 2101 2100 2090 +f 2030 2032 2101 +f 2091 2030 2101 +f 2092 2102 2033 +f 2031 2092 2033 +f 2093 2103 2092 +f 2103 2102 2092 +f 2094 2104 2093 +f 2104 2103 2093 +f 2095 2105 2094 +f 2105 2104 2094 +f 2096 2106 2095 +f 2106 2105 2095 +f 2097 2107 2096 +f 2107 2106 2096 +f 2098 2108 2097 +f 2108 2107 2097 +f 2099 2109 2098 +f 2109 2108 2098 +f 2100 2110 2099 +f 2110 2109 2099 +f 2101 2111 2100 +f 2111 2110 2100 +f 2032 2034 2111 +f 2101 2032 2111 +f 2033 2102 2035 +f 2036 2035 2102 +f 2036 2102 2112 +f 2112 2102 2103 +f 2104 2113 2103 +f 2113 2112 2103 +f 2105 2114 2104 +f 2114 2113 2104 +f 2106 2115 2105 +f 2115 2114 2105 +f 2107 2116 2106 +f 2116 2115 2106 +f 2108 2117 2107 +f 2117 2116 2107 +f 2109 2118 2108 +f 2118 2117 2108 +f 2110 2119 2109 +f 2119 2118 2109 +f 2111 2120 2110 +f 2120 2119 2110 +f 2034 2037 2120 +f 2111 2034 2120 +f 2036 2112 2038 +f 2039 2038 2112 +f 2039 2112 2121 +f 2121 2112 2113 +f 2114 2122 2113 +f 2122 2121 2113 +f 2115 2123 2114 +f 2123 2122 2114 +f 2116 2124 2115 +f 2124 2123 2115 +f 2117 2125 2116 +f 2125 2124 2116 +f 2118 2126 2117 +f 2126 2125 2117 +f 2119 2127 2118 +f 2127 2126 2118 +f 2041 2040 2127 +f 2041 2127 2120 +f 2120 2127 2119 +f 2037 2041 2120 +f 2039 2121 2042 +f 2043 2042 2121 +f 2043 2121 2128 +f 2128 2121 2122 +f 2123 2129 2122 +f 2129 2128 2122 +f 2124 2130 2123 +f 2130 2129 2123 +f 2125 2131 2124 +f 2131 2130 2124 +f 2126 2132 2125 +f 2132 2131 2125 +f 2045 2044 2132 +f 2045 2132 2127 +f 2127 2132 2126 +f 2040 2045 2127 +f 2043 2128 2046 +f 2047 2046 2128 +f 2129 2047 2128 +f 2048 2047 2129 +f 2130 2048 2129 +f 2049 2048 2130 +f 2131 2049 2130 +f 2050 2049 2131 +f 2132 2050 2131 +f 2044 2050 2132 +# 4272 faces, 0 coords texture + +# End of File \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/download_data.py b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/download_data.py new file mode 100644 index 0000000000000000000000000000000000000000..3d0ea2d006ab5919b442d29bc019792927f90b10 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/download_data.py @@ -0,0 +1,41 @@ +# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited. +import requests +from zipfile import ZipFile +from tqdm import tqdm +import os + +def download_file(url, output_path): + response = requests.get(url, stream=True) + response.raise_for_status() + total_size_in_bytes = int(response.headers.get('content-length', 0)) + block_size = 1024 #1 Kibibyte + progress_bar = tqdm(total=total_size_in_bytes, unit='iB', unit_scale=True) + + with open(output_path, 'wb') as file: + for data in response.iter_content(block_size): + progress_bar.update(len(data)) + file.write(data) + progress_bar.close() + if total_size_in_bytes != 0 and progress_bar.n != total_size_in_bytes: + raise Exception("ERROR, something went wrong") + + +url = "https://vcg.isti.cnr.it/Publications/2014/MPZ14/inputmodels.zip" +zip_file_path = './data/inputmodels.zip' + +os.makedirs('./data', exist_ok=True) + +download_file(url, zip_file_path) + +with ZipFile(zip_file_path, 'r') as zip_ref: + zip_ref.extractall('./data') + +os.remove(zip_file_path) + +print("Download and extraction complete.") diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/extraction.ipynb b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/extraction.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..650ee0d300e936764bf72d0839bd8bc1574284fb --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/extraction.ipynb @@ -0,0 +1,1668 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mesh Extraction from a fixed Signed Distance Field (SDF)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, we demonstrate how to use FlexiCubes to extract a mesh from a fixed signed distance field (SDF) **without** optimization. Note that in this case, the extraction scheme used is the original Dual Marching Cubes [Nielson 2004] algorithm, with minor improvements in splitting. To begin with, we will establish two functions: one for calculating the SDF of a cube, and another for determining its analytic gradient. In your specific application, the SDF might be predicted by a network, with gradients computed through methods such as finite differences or autograd." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import kaolin as kal\n", + "from matplotlib import pyplot as plt\n", + "\n", + "import render" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def cube_sdf(x_nx3):\n", + " sdf_values = 0.5 - torch.abs(x_nx3)\n", + " sdf_values = torch.clamp(sdf_values, min=0.0)\n", + " sdf_values = sdf_values[:, 0] * sdf_values[:, 1] * sdf_values[:, 2]\n", + " sdf_values = -1.0 * sdf_values\n", + "\n", + " return sdf_values\n", + "\n", + "\n", + "def cube_sdf_gradient(x_nx3):\n", + " gradients = []\n", + " for i in range(x_nx3.shape[0]):\n", + " x, y, z = x_nx3[i]\n", + " grad_x, grad_y, grad_z = 0, 0, 0\n", + "\n", + " max_val = max(abs(x) - 0.5, abs(y) - 0.5, abs(z) - 0.5)\n", + "\n", + " if max_val == abs(x) - 0.5:\n", + " grad_x = 1.0 if x > 0 else -1.0\n", + " if max_val == abs(y) - 0.5:\n", + " grad_y = 1.0 if y > 0 else -1.0\n", + " if max_val == abs(z) - 0.5:\n", + " grad_z = 1.0 if z > 0 else -1.0\n", + "\n", + " gradients.append(torch.tensor([grad_x, grad_y, grad_z]))\n", + "\n", + " return torch.stack(gradients).to(x_nx3.device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, let's call upon FlexiCubes to extract the mesh from this SDF, both with and without providing the gradient information." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "res = 5\n", + "device='cuda'\n", + "fc = kal.non_commercial.FlexiCubes(device)\n", + "voxelgrid_vertices, cube_idx = fc.construct_voxel_grid(res)\n", + "voxelgrid_vertices *= 1.1 # add small margin to boundary\n", + "scalar_field = cube_sdf(voxelgrid_vertices)\n", + "\n", + "mesh_with_grad_v, mesh_with_grad_f, _ = fc(\n", + " voxelgrid_vertices, scalar_field, cube_idx, res, grad_func=cube_sdf_gradient)\n", + "\n", + "mesh_with_grad = kal.rep.SurfaceMesh(vertices=mesh_with_grad_v, faces=mesh_with_grad_f)\n", + "mesh_no_grad_v, mesh_no_grad_f, _ = fc(\n", + " voxelgrid_vertices, scalar_field, cube_idx, res)\n", + "\n", + "mesh_no_grad = kal.rep.SurfaceMesh(vertices=mesh_no_grad_v, faces=mesh_no_grad_f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we visualize the two meshes. Without the gradient information (left), the extracted vertex locations are positioned at the centroids of the primal (Marching Cubes) mesh. Consequently, this method fails to reconstruct the sharp features present in the cube." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "camera = render.get_rotate_camera(0, iter_res=[512, 512], device=device)\n", + "f, ax = plt.subplots(1, 2)\n", + "output = render.render_mesh(mesh_no_grad, camera, [512, 512], return_types=['normals'])\n", + "ax[0].imshow(((output['normals'][0] + 1) / 2.).cpu())\n", + "output = render.render_mesh(mesh_with_grad, camera, [512, 512], return_types=['normals'])\n", + "ax[1].imshow(((output['normals'][0] + 1) / 2.).cpu())\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also visualize interactively with [kaolin's interactive visualizer](https://kaolin.readthedocs.io/en/latest/modules/kaolin.visualize.html), by moving around the camera and adjusting a wireframe to see the topology of the meshes." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9adcd325a6664219aeb6a2a4843ede3b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Canvas(height=512, width=1024), interactive(children=(FloatLogSlider(value=0.3981071705534972, …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "95aa177aef744427b5061f5cd1547f5c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render.SplitVisualizer(mesh_no_grad, mesh_with_grad, 512, 512).show(camera)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "0310e1f1b5744d52bad42a93c0b4cacd": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_8fd21a1694e34e89aed7c2a8d9e706c4" + } + }, + "0623f93c57da497993e106b73e986ef7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "076373e179904a4ea7bb68807ef129a9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "08a6bc9e8c2441998aa15ebc4c69667d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "09357156e94142fe8abc1f70c30e70ec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "0e971676622b4e24b3b7b4a4bbf82af8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "0f1e78a70fe049bfaab18c58610eb2aa": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_cad2738b444c452ebf92880dbd7c86f1" + } + }, + "0fc858ce475b4c5b854ee31d1ff0ce35": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_2e7fc70235424294be5f51f4ba00c6a8" + } + }, + "10785ebff0264da2a584b1cbdc280d7c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "13907e82d9bf42198fb63f62b7b8962b": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_8d390a6198e14de3abb4c02f86eed6e8" + } + }, + "14a8486500314b69a09ca2bb973b049e": { + "model_module": "ipyevents", + "model_module_version": "2.0.2", + "model_name": "EventModel", + "state": { + "_supported_key_events": [ + "keydown", + "keyup" + ], + "_supported_mouse_events": [ + "click", + "auxclick", + "dblclick", + "mouseenter", + "mouseleave", + "mousedown", + "mouseup", + "mousemove", + "wheel", + "contextmenu", + "dragstart", + "drag", + "dragend", + "dragenter", + "dragover", + "dragleave", + "drop" + ], + "_supported_touch_events": [ + "touchstart", + "touchend", + "touchmove", + "touchcancel" + ], + "_view_module": "@jupyter-widgets/controls", + "prevent_default_action": true, + "source": "IPY_MODEL_16a9d12b4d66495e937287d81d98ed86", + "throttle_or_debounce": "throttle", + "wait": 41, + "watched_events": [ + "wheel", + "mousedown", + "mouseup", + "mousemove", + "mouseleave", + "mouseenter", + "contextmenu" + ], + "xy_coordinate_system": "" + } + }, + "16a9d12b4d66495e937287d81d98ed86": { + "model_module": "ipycanvas", + "model_module_version": "^0.13", + "model_name": "CanvasModel", + "state": { + "_canvas_manager": "IPY_MODEL_74bbe62a9d604bc1902ed8de1ede91da", + "_model_module_version": "^0.13", + "_view_count": 2, + "_view_module_version": "^0.13", + "height": 512, + "layout": "IPY_MODEL_3593de689d2e4b278450682ae1cfbb80", + "width": 1024 + } + }, + "1cb8550bf1d948c599386ef05c6e3849": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_a487eb84e8204ecb917d2b7cd9b32355" + } + }, + "1f4281270d7047fcb9290b1d738ed731": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_d19ff89eddb544b9a3265ad5d782bd1b" + } + }, + "203326cb43394e3eb0a75166ddccf87d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "221ece0acf7e48c4a9e3cf24ee8d3cbf": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_d7995ce46a94421881e055f652521fac" + } + }, + "23d0f8680d6d4eecb025638aba77cc8f": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_3174998fe35e41c69a38a0ef6d559cea" + } + }, + "25be8dd0b3c94728b96f4776197809fa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "28cdb449c5ad4da7958d7b5c08e3efe4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "29a459cc6d794822ac02e5a849d426e4": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_36dac2661efa48f88a15361d15230877" + } + }, + "2e7fc70235424294be5f51f4ba00c6a8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "2ef59014e10f48b7a0b0c97c17de548e": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_6897285225264a61a60351eb926c2b31" + } + }, + "3174998fe35e41c69a38a0ef6d559cea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "31ab19682de744dd9f4ee5f995fbf14f": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_3fdfab044d404ec8b21a1eed31705844" + } + }, + "331d1e10b4d3476297f4f5d27508aeba": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_203326cb43394e3eb0a75166ddccf87d" + } + }, + "3354964add124253b5397b24cbd2f38e": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_e046c6442bc34b1eb9dfa1629f4552c3" + } + }, + "348d6a5be9d84dde93e2a7c996db64fb": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_dfefc663d1aa478eb813d24a111499bf" + } + }, + "35405d21bb3a405b9e23e6a3e8fd013d": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_55ccf38b8e654cbba4f8834766f734c5" + } + }, + "3593de689d2e4b278450682ae1cfbb80": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "365398449b8a4739988051896039fa3a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "36dac2661efa48f88a15361d15230877": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "3e67b0173c7d4d0aa14f17cfe314c0ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "3fdfab044d404ec8b21a1eed31705844": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "450886f5f96a463bb730ab2e08679b0f": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_b8a5514c3ef6441eabe6b134805c6bdd" + } + }, + "45a32f90ecdc4264ba917e6a77b5be84": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4887c0e8468349cbafcbd8b3d8aa6fbd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4b50d7e87a99479785b52622467fb5b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_16a9d12b4d66495e937287d81d98ed86", + "IPY_MODEL_9b59d44ffb7d4b238d06150e744f3b4d" + ], + "layout": "IPY_MODEL_0623f93c57da497993e106b73e986ef7" + } + }, + "4b8009c5e65a43919a112a502f7133ad": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_9bcec2011f0c486fb924fa7172df1eb4" + } + }, + "4cbc7bc2e74b498fbbc0308029da8556": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "layout": "IPY_MODEL_b29d1852b22d4b8085ba983605d04c94" + } + }, + "52219eab5a534c5eafd9e66fdc6c3f3c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "53598e9732c04146a6e652fd09275431": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_cfed2b9aa96e4204aa505002deb6e0fe" + } + }, + "53fd909a138245578e6033ab51e712e0": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_94b84a1da7284751a57189c75db9083e" + } + }, + "55164477924b4245b737ef500a432be0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "55ccf38b8e654cbba4f8834766f734c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "570818bdbfe7490abbd09a27602e7dde": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "572f59892959494ca9ebeefdfd5c80af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "5e1d0da65fef47868fe59005668870da": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "5ea918db99614846aeb2aa171b2c2e1d": { + "buffers": [ + { + "data": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdASFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2P/2wBDARESEhgVGC8aGi9jQjhCY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2P/wAARCAIABAADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwBKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKcqlqqMXJ2QDaKti1QoDlskUn2T/b/Ss3JJ2Z0fVqlrpFWirBtHzwyke9Na2kHQA/Q0cyIdCouhDRUpglAyUP4U3y5P7jflTuiXCS3QyilIwcHrSUyAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKkRO7flWlOnKo7ITdhETPJ6VWudTt7a5itQd87uq7B/CCepP9PpWZq3iIJmGwOXBwZcAj/gPr9f8A9dYensz6rbMxLM06kknJJ3CulVIUvdp6vuK19z0dPuL9K5GHxfdK5M9tC644CEqc/U5rrk+4v0ry6vOsnKVz0q9SUIx5WdT/AMJl/wBOH/kb/wCxq3/wl1h/zxuf++V/+Kri6KfJE51iqq6ndQ+J9MlQs8jwnONroSfrxmpotf0uWQIt2oJ/vKVH5kYrz+il7NFrGT7I9I/tOw/5/rb/AL+r/jVgeXKquNrqwyGHIIry+il7PzK+uX3ienmGNhgoPw4pPs8X939TXm0F1cW277PPLFu67HK5/Kp01XUEdWF7cZU5GZCR+R60cj7h9YpveB3/ANkj9W/OkNoM8OQPcVxX/CR6t/z9/wDkNP8ACp4vFeopGFZYJCP4mQ5P5ECi0+4e0w73idY1o38LA/Ximm1kx1U/jXOweMLhd32i1if02MUx+eanTxipdQ9iQueSJckD6Yo98LYZ9bfebP2eX+7+oppikBxsb8qpJ4ssndUSC6ZmOAAikk/nW4hLIrFSpIyVOMj24oc5LdFRw1KfwyM4qVOGBB96StSkIBGCAR70e08geC7SMyitHy4/7i/lTfs8X939TT9oiHg59GUKKum1jJ43D2BpptFx8rEH35p+0RDwtRFSirRtOOH5+lN+ySeq/nT54kPD1V0K9FTG3lz93P401oZF6ofw5p8yIdOa3TI6KcUcDJVgPcU2mS01uFFFFAgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooJCjJIA9TQAUUAgjI5FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFKBk4FKqljxQZoYpkgaRRK/3VzyeCenpwa3pUHU1eiE3YJHjtommmcKijJY9q5TVddmvv3cO6GHkEA8v9fbHb+dWPFqyfbIGOfKMeF54znnj8RWDV1qjj+7johJdQqzpv8AyE7X/rsn/oQqtVnTf+Qna/8AXZP/AEIVzx+JFHpCfcX6V5dXqKfcX6V5dWS+KR24r4Yf12CiiirOIKKKKACiiigAooooAKKKKAClRWd1RFLMxwABkk0IrO6oilmY4AAySa7bw/oS6eguLgBrph9RGPQe/qfw+sylymtKk6jsg8P6EunoLi4Aa6YfURj0Hv6n8PrqXV7BaNCsrYeZxGijqSTj8hmi+vYLC2ae4bag6AdWPoPeuHivZdQ8Q21xKT81wm1Sc7V3DAFZJOWrO+c40UoR3PQKYJEMrRA/OqhiMdAc4/kafXJ+Jb2ew1+Ce3ba4gGQejDc3B9qmKvobVans1zMteJtEe7/ANMtRmZVw8YHLgdx6n+Y+nPKQ3l1boUguZolJyQjlRn8K9D0+9i1CzjuIiPmHzKDna3cGuW8TaKtm4u7WMiBz86gcRn/AAP6fiBWkJfZZyYil/y8gZkWr6jFIHW9nJH95yw/I8VY/wCEj1b/AJ+//Iaf4VlUVpZHGqk1s2byeLdQVFUx27EDBYqcn34NTw+MJlQiezR2zwUcqMfQ5rmqKXJEtYioup1kXjGMyAS2TKncrJuI/DA/nVj/AIS6w/543P8A3yv/AMVXF0UuSJaxVRdTvU8S6UyKxuSpIyVMbZHtwKmg1vTJ92y8iG3rvOz/ANCxmvPKKXs0WsZPqkejpeac7qiXNqzMcAB1JJqwYI2OSg/DivMKtaV/yFrP/run/oQo5Guo1iYydnFHfXMSJGCq4OfWq1XLz/VD/eqnTg7oyxMVGpZIKKKKs5wooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiimTTRQJvldUX1JoSuCVx9NkkSJC8jBVHUk1iXfiNQStrHu4++3H6VjTXN1fzAO7OxPCjoKqxVjoZ9dhDeXaIZ5CcDsPzqjqGpSRoEZg1wRzjotQ/utLh7PcOPy/8Arfz/AJZTsXdmY5Zjkmtm/Zqy3/I6G/Yqy+J/h/wTd0zU2kwhfbKO3Z//AK9bFvfxTSeUx8ufH+rbv9D3FcTWnbXkc8XkXbEEY2Sd8/Xsfes9J77iUo1dJaPv/mdZRWFDqlzYssd8vmw5wsw6/j6/561tQTxXEYkhkV1PcH/OKhprRmEouLsx9FFFIkKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigApyoW+lNrG8R6lPbtHawMY9yB2dThup4Hp0rWko6ynshMn1fXIrRHgtGD3GdpOMhP8T/AJPpWPok0lx4ghlmcu7FiSf901lVpeHv+Q1b/wDAv/QTVqq51I9rrQLWRq68ovNKa4+TfbTshweg3FcY9fumuYrp7FhdSaxp52bnkkdNw7k4yfodtcxRiNWpd/0BBVnTf+Qna/8AXZP/AEIVWqzpv/ITtf8Arsn/AKEKxj8SGekJ9xfpXl1eop9xfpXl1ZL4pHbivhh/XYKKKKs4gooooAKKKKACiiigApUVndURSzMcAAZJNJXa+G9FWzgW7uIz9qccBh/qx/iR/h61MpWRrSpOpKyHeH9CXT0FxcANdMPqIx6D39T+H11L69gsLZp7htqDoB1Y+g96L69gsLZp7htqDoB1Y+g964HVNTn1S582X5UHCRg8IP8AH3rJJzd2d9SpGhHljuGqanPqlz5svyoOEjB4Qf4+9M0r/kLWf/XdP/QhVWrWlf8AIWs/+u6f+hCtrWR5yblO7PSa4vxl/wAhaL/rgP8A0Jq7SuL8Zf8AIWi/64D/ANCasae56WL/AIZR0TVG0u88wqXicbZFB7eo9x/j613kUkF5bB4yssMq+mQw7gj+leZVueHdbeylW1nO62dsAk/6snv9PX8/rc431Ry4avyvllsVtb0aXS58jL27n5JP6H3/AJ/yzK9LvrKC/tmguF3IehHVT6j3rz3ULKXT7yS3lB+U/KxGNy9iKcJXJxFH2butitRRRVnMFFFFABRRRQAVa0r/AJC1n/13T/0IVVq1pX/IWs/+u6f+hCk9io/Ej0G8/wBUP96qdXLz/VD/AHqp1NPY3xf8QKKKKs5gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooqG5vIbWMvK+AOoAyaaTew0m9iaorm6htULzSBR79TXPXviCaXK2y+Uv948tWTLLJM5eVy7HuTTsluOyW5t3niJy220QAA/efv+H5Viz3E1w++aRnb3NR0oBYgAEk8ACldvQV29BY0aRwiAsx6AVqfutLh7PcOPy/8Arfz/AJLCsem2vmSgGZu2eT7f5/wrLlkaWVpHPzMcmtv4S/vfkdFlRV/tP8BJHaRy7sWY9SabRT0hlkGUjdh0yqk1jqzn1bGUVbj027kKgRY3Yxkj+XWrsPhy8kJ3YUD2/wAcVXJLsaxoVJbRKtrfARfZ7ld8R4z3UVI0dxpjrcWspaM9x0x7+o960YvCzFMyS/N7HH9DWnFo0MEezeTFzlcf4k1drq0mdkMPOUbVPkUtO1yK6IjuMRSngf3W/wAK1qxLzw7E7M1tIUY8hW5H/wBaoIZNT0j5JITPbjJ4OQAB2PYfWsLq9jlqYepDVo6Kiq9lfW99HugfJHVTwR+FWKZzhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVieKQJIIJFYEQuY3HcEqGH6Ctuse//ANITVrb93ujEcybuvCjdj8Bj8fetqWqku/8Aw4mcxWl4e/5DVv8A8C/9BNZtaXh7/kNW/wDwL/0E1NL44+qB7FmxuPI8Uy5baskzxtxnOScD88VR1qLydWuV3bsvuzjH3uf60zUGZNVuWUlWWdiCDgg7jWp4mVZls71A+2WPHI4A6j8eT+VaP3oSXZh1MGrOm/8AITtf+uyf+hCq1WdN/wCQna/9dk/9CFYx+JDPSE+4v0ry6vUU+4v0ry6sl8UjtxXww/rsFFFFWcQUUUUAFFFFABRRXXeHdA8jbeXqfvescZ/g9z7+3b69FKSSNKdN1HZB4d0DyNt5ep+96xxn+D3Pv7dvr03b69gsLZp7htqDoB1Y+g96knnitoHmncJGgyzHtXB63rMuqT4GUt0PyR/1Pv8Ay/nik5vU9Cco4eFo7kOqanPqlz5svyoOEjB4Qf4+9UqKK3SseY25O7CrWlf8haz/AOu6f+hCqtWtK/5C1n/13T/0IUnsOPxI9Jri/GX/ACFov+uA/wDQmrtK4vxl/wAhaL/rgP8A0Jqxp7np4v8AhmBRRRW55R1fhfWl2LYXUh3ZxCzHjH93/D8vStjWdMTU7JovlEy8xuw+6f8AA9P/ANVeeV3Xh3WTqcDRz4FxEBuIwN49cfz/AA9cVlONtUd+Hqqa9nM4meCW2neGdCkiHDKe1R12viTRVvIGu7eM/akHIUf6wf4gf4elcVVxldHLWpOnKwUUUVRkFFFFABVrSv8AkLWf/XdP/QhVWrWlf8haz/67p/6EKT2Kj8SPQbz/AFQ/3qp1cvP9UP8AeqnU09jfF/xAoooqzmCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAA8jB5zWbd31hb3nkXETocZ37flIx7c+3Sq2t6mbe5giiJyjCSQK2Mjsv8An2pnie3BSC5GMg+W3PJ7j+td0JOnTfLutzoTcI+7uifGk3S7xcxZBxmXAP5HBom8PwtnZgZ5yCRj8ORXL0+KaWFi0MjxsRjKMQcVH1mMvjiT7Zv4lc2JfDzjBVnA9MBj+lT6fo0kD7jGzyHOCVwAPxqnpuqag93bwee7oXAIKhiRnnnGema2fEeo3NhHbLbOEL7tx2gnjHHP1oc6aXPBanRRlT1qOOxWPh2e5leS5l57YwAPbvT20HT7ZEF1cRoxzgu+M/qK5+XUb2bf5l3MQ+dy7zg57Y6Y9qrVg5+RLr091D7zqxJoFrMf3qFl7qpI/AqKhfxDp8cf7iyd2zyJMD9ea5qilzy7kvFz+zZG/L4quMgQW0MaAYw2W/liqcuv6lJvH2jYrZ4VQMD2OM/rWZWroWlDUJWlmyLeIjIGfnPpn+f/ANep1ZKqVqsuVMn0rT7jVWW4v5pXtUPy73JLnuB6D1P+RsXeqQ2t1b2caBnZlTYpwIweB/8AqqDWdXSxjFvbBfOxgADiMduPX0H+TybMzsWYlmJySTkk1d+T1N5VFQ92Gr6s7DXYjJpzsgPmRYkUg4II6n8s1z1vrV7AMGQSqB0kGf1611bbL2xz8wSaP8QGH/164VlKsVYEMDggjkGomlzMrFylCUZwdrm4NT0+7lD3EL283IEsbHI465HP6Gty0mSaHek4mXswxnoOvv8AgK4anRyPE4eN2Rh0ZTgiot2Of26l/Ejf8Gd7RXJ22u3kOBIVmUYHzjnH1H9c1q23iG1kGJg8LY5yNw/Mc/pRdrcPZ0p/BK3r/ma9FMimjnXdFIsgzjKMCM0+mmmZVKUqb94KKKKZmFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABWKrKfFVxBIm5LiLy25xxsB/pW1XLapKsHiTzmBKxvGxA64AU1rTlyu/mhMy5I2ileOQYdCVYehFaHh7/kNW//AAL/ANBNN12DyNWnADbXO8Fu+eTj2zn8qd4e/wCQ1b/8C/8AQTTjHlqpeYdCtqX/ACE7r/rs/wD6Ea2EH27wkwwzyWx6semDnj2CmsfUv+Qndf8AXZ//AEI1qeFmWSW6tZE3JLHluccDjH/j1VS/iOPe6B7GFVnTf+Qna/8AXZP/AEIVDPE0E8kLEFo2KkjpkHFTab/yE7X/AK7J/wChCsY6SQz0hPuL9K8ur1FPuL9K8urJfFI7cV8MP67BRRRVnEFFFFABRRXXeHdA8jbeXqfvescZ/g9z7+3b69FKSSNKdN1HZB4d0DyNt5ep+96xxn+D3Pv7dvr06GeeK2geadwkaDLMe1E88VtA807hI0GWY9q4PW9Zl1SfAyluh+SP+p9/5fzxSc2ehKUMPCy3DW9Zl1SfAyluh+SP+p9/5fzzKKK2SsebKTk7sKKKKZIVa0r/AJC1n/13T/0IVVq1pX/IWs/+u6f+hCk9io/Ej0muL8Zf8haL/rgP/QmrtK4vxl/yFov+uA/9Casae56eL/hmBRRRW55QVJBPLbTpNA5SRDlWHao6KA2PRNI1KLU7NZFYeaoAlTptb/D0rD8UaK29r+1jG3GZlUc5/vf4/n61g6bfSadepcxjdt4Zc4DA9R/nvivQbW4g1CyWZBuhlU/K4/Agj8xWLXI7o9KEliIcstzzSitjxFow0ydZIMm3lJ2g5Ow+mf5fj6ZrHrVO6uefODg+VhRRRTJCrWlf8haz/wCu6f8AoQqrVrSv+QtZ/wDXdP8A0IUnsVH4keg3n+qH+9VOrl5/qh/vVTqaexvi/wCIFFFFWcwUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABTZZFijaRzhVBJPoBTqw/Et5siS1U8yfM/0HT9f5VrTWvM9kXBdX0MG5mNzcyTNnLsTgnOB6V0EIGo+GygAMka4AC5IK9APcj+dc1W54YnInmg5Kld454BBx098j8quhK87PqVTd3Z9TDoqzqVuLW/mhGAqtlQDnAPI/Q1WrBqzszI0vD6s2sQ7VJwGJx2+Uj+tXfF8rG8ghIG1I9wPfJOD/wCgimeE42a/kkA+VY8E+5II/kah8TytJrMikDESqox6Yz/U1b0gl6/1+B0R0oPzZk0UUVmc4UUVo6RpUmpS5YlLdD87/wBB7/y/mFRi5uyDSNKk1KXLEpbofnf+g9/5fz39Uv4NKshb24CPtxEi/wAP+0f88n8aXUdQg0i1SGBFDAYjiHb3P+efzNcjNLJPK0srF3Y5JNafB6nZKUcPHlj8TGszOxZiWYnJJOSTSUUVmcJ2GgSibSIxuLMhKHPbngfkRXO6zD5OqTABsMd4J755P65rT8Kz/wCvty3o6rj8Cf8A0Go/FMQWeCUZ3MpUjtgH/wCvVT2TPRqe/hlLt/wxhUUUVJ5wUqqWYKoJYnAAHJNJW54as/Mna6YcJ8qfU9f0/nSbsrmlKm6k1FGpAItH0+FZCoLOqk5wCxPJzjsM9ewrQPWuU8Q3n2m+8pT+7gyo927/AOH4V0ljP9psYJt24sg3HGMsOD+uazimnd9TpxE1NOMdok1FFFanEFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXI6//AMhif6L/AOgiuurkdf8A+QxP9F/9BFV9lgSa1ia20+68wuZINjZ65Xqc/Un8qZ4e/wCQ1b/8C/8AQTUilp/C7LvU/ZpwdvcKRj+bH9aj8Pf8hq3/AOBf+gmtt6sX3sLoVtS/5Cd1/wBdn/8AQjT9InW21S3lbG0NtJJwACMZ/DOaZqX/ACE7r/rs/wD6EarVk3yzuu4zU8RweTq0hAULKA4C/kc++Qaqab/yE7X/AK7J/wChCtjxA32vSbG93Lk8EL0ywyfyK4rH03/kJ2v/AF2T/wBCFa1Farp1Etj0hPuL9K8ur1FPuL9K8urkXxSO7FfDD+uwUUUVZxBRRXSeHdA8/beXqfuuscZ/j9z7e3f6dU2ki6dN1HZFjwxoiCOPULkbnPMSEfd/2j7+n5/TpXZURndgqqMkk4AFDsqIzuwVVGSScACuJ8Qa62oObe3JW1U/QyH1Pt6D8fpjZzZ6TlDDwsV9b1mXVJ8DKW6H5I/6n3/l/PMoorZKx5kpOTuwooopkhRRRQAVa0r/AJC1n/13T/0IVVq1pX/IWs/+u6f+hCk9io/Ej0muL8Zf8haL/rgP/QmrtK4vxl/yFov+uA/9Casae56eL/hmBRRRW55QUUUUAFauhavJplyFZs20jDzFP8P+0Pf+f5VlUUmrlRk4u6PTZY4Ly2KSBZYZV9chh2IP9a8/1TTJ9LufKl+ZDykgHDj/AB9q1fDOtpaf6HdHELNlJCeEJ7H0H8j9eOk1TTINUtvKl+VxykgHKH/D2rJNwdmehJLEQ5o7o85oqW6t5LS5kt5Rh42Kn39x7VFWx5rVtAq1pX/IWs/+u6f+hCqtWtK/5C1n/wBd0/8AQhSexUfiR6Def6of71U6uXn+qH+9VOpp7G+L/iBRRRVnMFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA2WRYo2kc4VQST6AVxF3cNdXUk78FznHoOw/Kt3xLebIktVPMnzP9B0/X+Vc5Ws/dSh95ctFyhVnTrgWt/DMcBVb5iRnAPB/Q1WorNOzuiU7O5v8Aii3OYLkZxjy254Hcf1/KsCumkzf+Gd7Ab1Tdljk5U8nPqQD+dczW+IS5uZdS6i96/c6XwhGwFxJj5CVAPuM5/mKx9ZlabV7pmABEhXj0HA/lXReFI2TTmZhgPISvuOB/MGuTnlaeeSZwA0jFiB0yTms6myXkaz0oxXdjKKKuabp02o3HlxfKg5dz0Uf4+1ZnPGLk7IXStPk1G6WNQfKUgyP02r/j6V0+pXkOkWCJBGox8sUeePqe/wD+v3onntNDsAka8fwrn5pG9T/j/wDWFcjd3Ut5O00zZY9B2A9BWnwep3NrDR5V8T/AZNLJPK0srF3Y5JNMoorM4G7hRRRQBp+Hp/J1VASoEgKEn8x+oFbPiSLfprNnHlsrdOvb+tctDK0M8cqgFkYMM9Mg5ruruLz7aSLO3epXOM4yKreD8j0cL79KUDgqKKKk84dGjSyLGgyzEKB6k11lw66Po2Iz84GxD6se/f3NZvhqz8ydrphwnyp9T1/T+dQeIbz7Tf8AlKf3cGVH17/4fhWUvelyndT/AHNF1Or0RlV1Hhm4MljJASSYWyOOMH/6+a5etbw3OY9TEXJWZSpGeAQM5/Q/nVz2uc1H4uXvodTRS0lUZBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVyOv/APIYn+i/+giuurkdf/5DE/0X/wBBFV9lgTaDmaG/tBGHaWAsufUdP1P6VF4e/wCQ1b/8C/8AQTUeiSrDq9szAkFtvHqQQP51c02EW/inyghRVkkCg+mDj9K3hryPsxMztS/5Cd1/12f/ANCNVqs6l/yE7r/rs/8A6EarVhL4mM6LTGF94burTkvCCVVByf4h9ckEVjab/wAhO1/67J/6EK0vCtx5eoPCWwsqcDHVhyP03VVS2Np4gigwcJcKFyckjcMfpit370YS+Qj0BPuL9K8ur1FPuL9K8urjXxSO7FfDD+uwUUV0nh3QPP23l6n7rrHGf4/c+3t3+nWm0kctOm6jsg8O6B5+28vU/ddY4z/H7n29u/069a7KiM7sFVRkknAAodlRGd2CqoySTgAVxPiDXW1Bzb25K2qn6GQ+p9vQfj9MdZs9JuGHh5h4g11tQc29uStqp+hkPqfb0H4/TEoorZK2iPMnNzd2FFFFMkKKKKACiiigAq1pX/IWs/8Arun/AKEKq1a0r/kLWf8A13T/ANCFJ7FR+JHpNcX4y/5C0X/XAf8AoTV2lcX4y/5C0X/XAf8AoTVjT3PTxf8ADMCiiitzygooooAKKKKACuy8M6014htLqQGdB8jE8yD/ABH6/gTXG0qMyOroxVlOQQcEGplG6NaVV05XR3XiHSP7Stg8Kr9pj+6TxuH93P8An8MmuFdWR2R1KspwQRgg13uhavHqdsFZsXMajzFP8X+0Pb+X5Vm+J9EQxyahbDa45lQD73+0Pf1/P6xF2fKzqr01Uj7SBydWtK/5C1n/ANd0/wDQhVWrWlf8haz/AOu6f+hCtHscUfiR6Def6of71U6uXn+qH+9VOpp7G+L/AIgUUUVZzBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU2WRYo2kc4VQST6AU6sPxLebIktVPMnzP9B0/X+Va01rzPZFwXV9DCu7hrq6knfguc49B2H5VDRRWbd3dkN3CiiikB0Hhe4GJrc4yD5i8cnsf6VjX1ubS9lg5wjYGTk47fpiptImMGpwEZIZthAOMg8f/AF/wq/4nt9s0Vyo4cbGwvcdMn1x/Kul+/Rv2NXrC/Y1tKMlp4c83aN6RNIoPIPVh/SuNrsrsyWnhdgVAcQrGwPOM4U/zNcpZ2k19cLBAuWPUnoo9T7VlV+KxpWTtCK7fmS6bp02o3HlxfKg5dz0Uf4+1dRPPaaHYBI14/hXPzSN6n/H/AOsKWNbbQtNKlyVByzd3Y+g/D/PWuT1C9kv7ozSALxhVHYenvR8Kv1NtMND+8xl3dS3k7TTNlj0HYD0FQ0UVmcLbbuwooooEFFFFABXa6TL52k27Y24Tb1z93j+lcVXTeFZVNpPFg7lfcfTBGP6Grhq7dzswcrVLdzD1OH7PqM8eFADkgL0APIH5GobeF7idIYxlnOB/jWr4mh2XkcoCgOuDjqSO5/Aj8qm8NWWS124/2Y8j8z/T86ybsrsXsOau4f1Yv3txHpGmKkX3yNkY4znH3j/Pp1+tcjWjrd79sv22NmKL5EweD6n8f5YrOpQVldk4mrzzstlsFPhlaGeOVQCyMGGemQc0yirOZOx34ZWAZSGVhkEHIIoqlotwLjS4TxujHlsAOmOn6Yq7Uw2NaqXO2uuv3hRRRVGQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVyOv/wDIYn+i/wDoIrrq5HX/APkMT/Rf/QRVfZYGerMjBlJVlOQQcEGumYRnxXazxMWWeLzMn/dYD9AK5iup0zNxDpE7SBmiaSIgdvlbH6KPzrfD6u3mn+Imc/qX/ITuv+uz/wDoRqtVnUv+Qndf9dn/APQjVasJfExk9lP9mvYZ8sAjgnb1I7j8q3NYt/L8RWUwXCyumTnqwYA/ptrnK6w/6bpemXI5aKaPcz/ePzbTz7nBrej70XH5iZ0qfcX6V5dXqKfcX6VyPhvQlugt7dgNDn93H13kHqfbPbv9OvFe0pM9GtB1OSK/rYXw7oHn7by9T911jjP8fufb27/Tr19Fch4i1/z91nZP+66SSD+P2Ht79/p1jWbNvcw8P61IvE2s/bJfstrLm2T75Xo7fXuB/P8ACsCiitkrKx5k5ucuZhRRRTICiiigAooooAKKKKACrWlf8haz/wCu6f8AoQqrVrSv+QtZ/wDXdP8A0IUnsVH4kek1xfjL/kLRf9cB/wChNXaVxfjL/kLRf9cB/wChNWNPc9PF/wAMwKKKK3PKCiiigAooooAKKKKAJrO6lsrqO4hI3xnIyMg9iPyr0LTb6PUbJLmMbd3DLnJUjqP89sV5vV7SNSl0y8WRWPlMQJU67l/x9KicbnRh63s3Z7Gh4k0VrOdru3jH2VzyFH+rP+BP+HpWXpX/ACFrP/run/oQr0JWgv7PKsJYJkIyD1B4P0rjptLbS/ENnGGLxPMjRsR23Dg+4/w9aUZXVma1qPLJTjszsLz/AFQ/3qp1cvP9UP8AeqnTp7GeL/iBRRRVnMFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFADZZFijaRzhVBJPoBXEXdw11dSTvwXOceg7D8q6/UbVr22MCy+UCQWO3OQO354rJ/4Rr/p7/8AIf8A9euuVCpyqKRu6crJJGBRW/8A8I1/09/+Q/8A69H/AAjX/T3/AOQ//r1n9Wq9ifYz7GBRW/8A8I1/09/+Q/8A69H/AAjX/T3/AOQ//r0fVqvYPYz7GBXV3SNq2hq0SB5WCsoBwAwOD1/Gqf8AwjX/AE9/+Q//AK9aumWZsLfyTMZRuJBIxgenX/Oa3oUZxupLRlwpyV00P1qC4udOS2t0DNNIFYnoq8nPt0FMjjtNC09vm/33x80jeg/w/wDrmtJ2wAoP1rGvtGkv7oST3h8sH5Y1TGB7HPX3rFptuR6Dg4rmiru1vQ5zUb+XUJ/Mk4UcIg6KP896q11X/CNWf/PWf/vof4Uf8I1Z/wDPWf8A76H+FZunJnHLC1pO7OVorqv+Eas/+es//fQ/wo/4Rqz/AOes/wD30P8ACj2cifqlU5Wiuq/4Rqz/AOes/wD30P8ACj/hGrP/AJ6z/wDfQ/wo9nIPqlU5Wiuq/wCEas/+es//AH0P8KP+Eas/+es//fQ/wo9nIPqlU5Wtfw1P5epGMlsSoQAOmRzk/gD+daf/AAjVn/z1n/76H+FS2uhW1pcJPFLNvQ5GSpH8qcYSTuaU8NUhNSGa/ZPdww+UmZBIBn+6DwT+eKNSmTStJEUJ2uw8uPsfduMfn6kVqsMkVmano76jOsjXWxFGFTZnHqev+eK5qzSnZ7HbVg0nKC95nI0V0P8Awi//AE+f+Qv/AK9H/CL/APT5/wCQv/r0e1h3PN+q1u35HPUV0P8Awi//AE+f+Qv/AK9QN4Zuwx2zQFc8EkgkflR7SHcTw1VdCbwtcHM9sScY8xeOB2P9PyrfrE0zRb2xvo5zJCUGQwVyMg/h+P4VuHrRGSbdgqwlGEXJeQlFFFaHOFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFcjr/8AyGJ/ov8A6CK66qV3oNre3DXEskwdwMhSMcAD09q1p05VE1ETdjja6fwlKxguYcDarBge+SMf0FXV0DTVUAwFiBjJdsn8jVi00yzspTJbw7HI2k7iePxPtXXRw86c1Jkt3OM1L/kJ3X/XZ/8A0I1Wrt5NE0+WV5JLfLuSzHe3JP41Mum2KqFFnBgDHMYJ/M1Dwk227j5jgq6jwlLm2uIdv3HDZz1yMf8Asv61rf2fZf8APnb/APfpf8KfFa28DFoYIo2IxlEAOPwrWlhpU581xN3NBPuL9KEVURURQqqMAAYAFCfcX6UOqujI6hlYYIIyCK8WfxM9+Hwo5LxFr/n7rOyf910kkH8fsPb37/Trzdekf2ZYf8+Nt/36X/Cj+zLD/nxtv+/S/wCFUppI46mGnUd2zzeivSP7MsP+fG2/79L/AIUf2ZYf8+Nt/wB+l/wp+0RH1OXc83or0j+zLD/nxtv+/S/4Uf2ZYf8APjbf9+l/wo9og+py7nm9Fekf2ZYf8+Nt/wB+l/wo/syw/wCfG2/79L/hR7RB9Tl3PN6K9I/syw/58bb/AL9L/hR/Zlh/z423/fpf8KPaIPqcu55vRXpH9mWH/Pjbf9+l/wAKP7MsP+fG2/79L/hR7RB9Tl3PN6taV/yFrP8A67p/6EK77+zLD/nxtv8Av0v+FKmnWSOrpZ26spyCIlBB/Kj2iGsHJO9y1XF+Mv8AkLRf9cB/6E1dpUE1na3Dh57aGVgMAugY4/Gs4uzuddam6keVHmdFekf2ZYf8+Nt/36X/AAo/syw/58bb/v0v+Fae0Rx/U5dzzeivSP7MsP8Anxtv+/S/4Uf2ZYf8+Nt/36X/AAo9og+py7nm9Fekf2ZYf8+Nt/36X/Cj+zLD/nxtv+/S/wCFHtEH1OXc83or0j+zLD/nxtv+/S/4VXl0DS5ZC7Wign+6xUfkDin7RCeDl0Z5/RXff8I5pP8Az6f+RH/xo/4RzSf+fT/yI/8AjR7RC+pz7o5vw9rf9myGCcZtpGySByh9fce3+T2s0EU4QSoG2OHXPZgcgis7/hHNJ/59P/Ij/wCNaMEMdvAkMQIRBhQWJwPqazk09UddGnOC5Z6ojvP9UP8AeqnVy8/1Q/3qp1rT2OLF/wAQKKKKs5gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA0d801kzWxjE4GB5gJXPvjFcpceKtVtp3hntrZJEOGUo3H/j1b8RZg8SyGJpBhXH8Ldj789uh71mzRQeJbd4pFW21W1yrLnjg4P1XP5H9ejmclo9RJ9CrB4zmVCJ7ON2zwUcqMfQ5qT/hNf8AqH/+Rv8A7GuXuIJbad4Z0KSIcMp7VHWftZrqVc6z/hNf+of/AORv/saP+E1/6h//AJG/+xrk6KPaz7hc6z/hNf8AqH/+Rv8A7Gr+jeJF1S9Ns1uIDsLKTLncRjgDA7ZP4Vwlavhl1TX7UuwUZYZJxyVIA/OqjVk2rsLnearff2dpst55fmeXt+TdjOSB1/Guc/4Tj/qHf+R//sa3tdhW40G8RyQBEX49V+YfqK8zrJqzaN6lSStY67/hOP8AqHf+R/8A7Gj/AITj/qHf+R//ALGuRopGftZ9zrv+E4/6h3/kf/7Gj/hOP+od/wCR/wD7GuRooD2s+513/Ccf9Q7/AMj/AP2NH/Ccf9Q7/wAj/wD2NcjRQHtZ9zrv+E4/6h3/AJH/APsaP+E4/wCod/5H/wDsa5GrWn6ddalOIrWItyAzY+VPcnt0NA1Vm+p0yeNWkdUTTCzMcBRNkk+n3a6m1M0sCNPEIpCMsgfdt9s45rN03SrDw9aS3Dychf3k8nXHoB2Ge3J6deKzU8QS6t4itrKxlMNmHyW2/NLt+b6gHbj8efSob7Gyk4/E9To765isrSSeU4SNSx6ZPsPc9K5X/hN/+od/5G/+xrQ8b3XlaR5IKZmkCkHrgckj8QPzrga54Uo1G5SIqVGnZHXf8Jv/ANQ7/wAjf/Y0f8Jv/wBQ7/yN/wDY1yNFafVqXYz9rPudd/wm/wD1Dv8AyN/9jR/wm/8A1Dv/ACN/9jXI1ueH9G+0Z1G8+Sxgy5yufM28kY9OOfy+kyo0Yq7Q4znJ2TOx0m/n1C1+0TWn2ZG5jBfcWHr0GB6ev86kr75Wbnk55qDTtSm1Vry8IZLVB5MKZHJPUt7/AHfYZI9TUlFCnytsqrLRIKKKK6TAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKpXevWtlcNbyxzF0AyVAxyAfX3q7XI6//wAhif6L/wCgitadSVNNxE1c6Ndf01lBM5UkZwUbI/IVYtNTs72Ux2829wNxG0jj8R71wddP4SiYQXM2RtZgoHfIGf6iuujiJ1JqLJasal1qtnaTeVcSlHxnBRuR+VOXUrFlDC8gwRnmQA/kawfFiIZredG3FgyHByPlP88k1gUVMTKE3GwJXO+/tCy/5/Lf/v6v+NKt9ZuwVbqBmY4AEgJJrgKs6b/yE7X/AK7J/wChCpWMk3aw+U9IT7i/Sq39p2H/AD/W3/f1f8asp9xfpXl1eY480merUrOlGNluekf2nYf8/wBbf9/V/wAaP7TsP+f62/7+r/jXm9FHs0Y/XJdj0j+07D/n+tv+/q/40f2nYf8AP9bf9/V/xrzeij2aD65Lsekf2nYf8/1t/wB/V/xo/tOw/wCf62/7+r/jXm9FHs0H1yXY9I/tOw/5/rb/AL+r/jR/adh/z/W3/f1f8a83oo9mg+uS7HpH9p2H/P8AW3/f1f8AGj+07D/n+tv+/q/415vRR7NB9cl2PSP7TsP+f62/7+r/AI0f2nYf8/1t/wB/V/xrzeij2aD65Lsekf2nYf8AP9bf9/V/xq3XI+GtCaR47+6BVFIaJOhY9mPt6ev069VNPFAEMrhd7hFz3YnAArOSSdkdlKcpR5pKxJUE15a27hJ7mGJiMgO4U4/Gp64vxl/yFov+uA/9CaiKu7BWqOnHmR1P9p2H/P8AW3/f1f8AGj+07D/n+tv+/q/415vRWns0cf1yXY9I/tOw/wCf62/7+r/jR/adh/z/AFt/39X/ABrzeij2aD65Lsekf2nYf8/1t/39X/Gj+07D/n+tv+/q/wCNeb0UezQfXJdj0j+07D/n+tv+/q/41Xl1/S4pCjXakj+6pYfmBivP6Kfs0J4yXRHff8JHpP8Az9/+Q3/wo/4SPSf+fv8A8hv/AIVwNFHs0L65Psjvv+Ej0n/n7/8AIb/4VowTR3ECTRElHGVJUjI+hrivD2if2lIZ5zi2jbBAPLn09h7/AOR2s08UAQyuF3uEXPdicACs5JLRHXRqTmuaeiI7z/VD/eqnVy8/1Q/3qp1rT2OLF/xAoooqzmCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArH8SRy21zb6xauUkYhHYdnA4P4r2xjj3rYpXgS7t5rOU4Sdduf7rdVP4Gqj2EzO/0XxZY8bYNShX8CP6r+oP68pcQS207wzoUkQ4ZT2p0Us9ldCSMvDPE3pgqe4I/pXYQzWfivTjDMBFeRDPHVT/AHl9VPcf/WNX8fqBxNFWL+yn0+6a3uF2uvII6MPUe1V6yasMKsadKkOo2ssh2okqMxxnABBNV6KFoB6vNCtzaSwOSElQoSOoBGK8or1i2lSeFZYzujdQynGMg9K8uv4Vtr+5gQkrFKyAnrgEirqfEzaprGLIKKKKgxCiiigAoorqNA8KvdDz9SSSKMH5Yfus3POfQdvX6dwqMXJ2RnaFoNxqsys6vFajlpcfe56L6nj8P0PaNJpnhrTkR28tOdqgZeRscn69Oeg46cVBrWv2uiJ9lgQSXIT5I1GEj9M+nHYfpnNcHe3tzqFwZ7uUyyYAyeMD0AHAqdZGrap6Lctaxrl3q8v75tsAbckK9F/xPufU4xWz4Bg3Xt3cbseXGE2467jnP/jv61yld/4KtvI0NpyE3TyFgR12j5QD+IP51NRqMWRTvKV2Y3jm683UYbcFCIoyxx1BY9D+AB/GuZrR8Qz/AGjXbx9u3EmzGc/d+XP6VnUUlaCRM3eTCiiruk6bLqt6tvEQoxudz/Cvc479attJXYkr6IsaFokurT5OY7ZD+8k9f9ke/wDL8gZ/EGs/aMafZ/JYwYQANnzNvAOe444/P6T67fRafB/Y2lkLCo/fuDlmbuCf5/lxjFYFvC1zcxQIQGlcICemScVlFcz55fI0furlW52ejwfZdBtUKBXlJmbnOc/dP/fOKsVLcbRLsQAIgCqoGAAO1RVcPhuTU+K3YKKKKsgKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK5HX/APkMT/Rf/QRXXVyOv/8AIYn+i/8AoIqvssDOrqdMzbw6RA0YVpWklJHf5Wx+jD8q5dVZ2CqCzMcAAZJNdMxjHiu1giUqsEXl4P8AusR+hFb4fR380vxEyLUd1xo15kgC2vXxgdQW/wDs/wBK52uhsV+0X+sWW1SZt5BboCGIH6tn8K56pra2l/WgIKs6b/yE7X/rsn/oQqtVnTf+Qna/9dk/9CFZR+JDPSE+4v0ry6vUU+4v0ry6sl8UjtxXww/rsFFFFWcQUUUUAFFFFABRRRQAUUUUAFbnh3RHvZVupxttkbIBH+sI7fT1/L6Q+H9IbUroPKh+yxn5znGT/dH9fb8K7r93BF/DHHGv0CgfyFZzlbRHZh6HN78thJ54raB5p3CRoMsx7Vx02sy6prlmBlLdLhNkf/Ahyff+X84/EOt/2lIIIBi2jbIJHLn19h7f5GfpX/IWs/8Arun/AKEKUY2V2OtX55KMdj0muL8Zf8haL/rgP/QmrtK4vxl/yFov+uA/9Capp7nRi/4ZgUUUVueUFFFFABRRRQAUUUUAFXtI02XU7xY1U+UpBlfptX/H0qvZ2st7dR28IG+Q4GTgDuT+VehabYx6dZJbRndt5ZsYLE9T/ntionKx0Yej7R3exIqwWFnhVEUEKE4A6Acn61x02qNqniGzkClIkmRY1J7bhyfc/wCHpT/EmtNeTtaW8g+yoeSp/wBYf8Af8fSsvSv+QtZ/9d0/9CFKMbK7Na1bmkoR2R6Def6of71U6uXn+qH+9VOnT2M8X/ECiiirOYKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDnfFFlsuEvo1wk/D4HAkHXtjkc/XNY1vPLazpPA5jkQ5Vh2rt7q1W/tJbRsAyD5GP8Lj7p6H6H2JrhXRo3ZHUqynBUjBB9Kp9xeR2MV5Y+KbUWlyvkXqruU44z3K+o45B/pmuVv7KfT7pre4Xa68gjow9R7VAjtG6ujFWU5DA4IPrXW2d3beJ7IWV8RHfICY5APve4/qv4j2u/PvuGxyNFWL+yn0+6a3uF2uvII6MPUe1V6yasM9M0GVJdHs2jOVEKqeO4GD+oNcN4khW31+8RCSC+/n1YBj+prrfCEqPocKocmNmVhjock/yIrnvGkKxa5vUkmaJXbPY8rx+Cirqbp+Rs9aZgUUUVBiFSW9vLdTpBAhklc4VR3qxpumXWpzGO1j3bcbmJwqg9yf8ng13un6Xp/h+ze4chSqfvZ36t9B257Drx1NJuxpCDlq9ij4f8LR2flXV4N90OQmQVjPb6kevT8s1W8QeK0EclppbHfkq9wOmP8AYP8AX8vWsvXfE9xqX7m2D21sMggN80nb5sdsdv58Vg0rX3KlNJcsRzu0js7sWdjlmY5JPqabRRVGIV6fCDpfh2PdCA9vbbnjBAywXJ5Hqc8155o9r9t1a1tym9XkG9c4yo5b9Aa7fxnOsWhyIwJMrqi47HO7n8FNYV9bR7m1LROR55RRSojSOqIpZmOAoGST6VuYktpbSXl1FbwjLyMFHXj3PsOtdNqVxbeHdObTrByb2UAyzLwR7n046DtnPuXK1t4V05SVEmpzpkqf4fbjooP5kflyTu0js7sWZjksTkk+tYL9679F+Jr/AA15/kJW54RtzJq/2j5glvGzkhcgkjGM9upP4Vh11vhaEw6RPcYcNPIEGeAVUdR+JIrSe1u5NP4r9jTJJOSck0lFFWQFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXI6/wD8hif6L/6CK66uR1//AJDE/wBF/wDQRVfZYDNEiWbV7ZWJADbuPUAkfyq5pswuPFPmhy6tJIVJ9MHH6UzQcww392JAjRQFVz6np+o/WovD3/Iat/8AgX/oJreGnIu7Eya0n8jxS5Jba87oQvfJIGfbOPyqhqNv9l1CeELtVXO0Zz8vUfpinXsjRavcSRnDpOzKfQhqu+J41GoJNGMpNGG3jkMenB+mKmWsH5P8wMerOm/8hO1/67J/6EKrVZ03/kJ2v/XZP/QhWUfiQz0hPuL9K8ur1FPuL9K8urJfFI7cV8MP67BRRRVnEFFFFABRRRQAUUUUAFX9G0x9TvVi+YQrzI6j7o/xPT/9VRabYyajepbRnbu5ZsZCgdT/AJ74r0GxsoLC2WC3Xag6k9WPqfeonKx04eh7R3exJBBFbQJDAgSNBhVHauT8Sa6t0GsrQhoc/vJOu8g9B7Z79/p1s+J9bQRyafbHc54lcH7v+yPf1/L6cnUwj1Zria/2IBVrSv8AkLWf/XdP/QhVWrWlf8haz/67p/6EK0exxx+JHpNcX4y/5C0X/XAf+hNXaVxfjL/kLRf9cB/6E1Y09z08X/DMCiiitzygooooAKKKKAClRWd1RFLMxwABkk0ldl4Z0VrNDd3UYE7j5FI5jH+J/T8SKmUrI1pUnUlZFzQtIj0y2DMubmRR5jH+H/ZHt/P8qzfE+toI5NPtjuc8SuD93/ZHv6/l9L/iHV/7NtgkLL9pk+6DztH97H+fxwa4V2Z3Z3YszHJJOSTURV3zM6q9RU4+zgJVrSv+QtZ/9d0/9CFVataV/wAhaz/67p/6EK0exxR+JHoN5/qh/vVTq5ef6of71U6mnsb4v+IFFFFWcwUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXO+KLLZcJfRrhJ+HwOBIOvbHI5+ua6Ko7q1W/tJbRsAyD5GP8Lj7p6H6H2JprsJnCUqO0bq6MVZTkMDgg+tDo0bsjqVZTgqRgg+lJSGddZ3dt4nshZXxEd8gJjkA+97j+q/iPbmb+yn0+6a3uF2uvII6MPUe1QI7RuroxVlOQwOCD611tnd23ieyFlfER3yAmOQD73uP6r+I9tPj0e4E/geVDp88QPzrNuIx0BAA/kaqePIVW5tJwTudGQjthSCP/QjU3hWCXTdTvbG5QrKUV1I+6ygkZB/4EP1qbx1CrWFtOSdySlAO2GGT/6CKJ7I2jrTaOJrZ0Pw9cao6SuDFaZOZO7Y7KP69OvpitLQPCjyt5+qRlY8fJDnBbI6nHI+nXP66mt+IrfSIltrAQy3C/LtH3IgOMHHfjGP8nJsUYJLmkWrqfT/AAzpvyRBQSfLhU8yN9T+GSegx7CuF1jVrjV7vzpjtReI4weEH9T6n/61Vbm4mu7h57iQySucsx71FQl1YpzctOgUUUUzMKKKKAOi8EWvna0ZiH2wRlgR03HgA/gT+VWvHd1untrUF/lUyMP4Tk4H4jB/OrvgW28rTLi6IcNNJtGRwQo4I/EkfhXN+J7gXGvXJVy6oQgznjAwQPxzWD96qvI2elP1Mquq0yCDw7p/9o6hF/psmRBET8wGPTsfU9hgdTgxaBpyWFu2takmIY1zChXLE5GGx/LPrnjg1katqk+q3RmmO1BxHGDwg/x9TRL94+Vbdf8AISXIuZ79CC9u5b67kuZyDJIcnAwB2A/KoKKK3SsZN31Cu/hg+yWFpa7AjRxDeuc4Y8t+tcdolt9r1i1hwpBkDMH6EDkj8ga7WZ98ztnIJ4+lQ9ZLyLWkG+5HRRRVkBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVyOv/APIYn+i/+giuurkdf/5DE/0X/wBBFV9lgSqGg8Ls2xR9pnA3dyoGf5qf1qPw9/yGrf8A4F/6CafrWIbbT7Xyyhjg3tnrluox9Qfzpnh7/kNW/wDwL/0E1ttViu1hdCtqX/ITuv8Ars//AKEa0tR/f+HNPuH4dCYgB0xyPz+UfrWbqX/ITuv+uz/+hGtLS/8ASPD+o2/3fLxLu6574x/wD9aIaylHvf8AzAxKs6b/AMhO1/67J/6EKrVZ03/kJ2v/AF2T/wBCFYx+JDPSE+4v0ry6vUU+4v0ry6sl8UjtxXww/rsFFFFWcQUUUUAFFFFABU1nay3t1Hbwgb5DgZOAO5P5U2CCW5nSGBC8jnCqO9d3omjRaXBk4e4cfPJ/Qe38/wCUylY3o0XUfkT6XpkGl23lRfM55eQjlz/h7VneJNaWzga0t5D9qcclT/qx/iR/j6VZ13V49Mtiqtm5kU+Wo/h/2j7fz/OuCdmd2d2LMxySTkk1nGN9WdVesqa9nASiiitjzgq1pX/IWs/+u6f+hCqtWtK/5C1n/wBd0/8AQhSexUfiR6TXF+Mv+QtF/wBcB/6E1dpXF+Mv+QtF/wBcB/6E1Y09z08X/DMCiiitzygooooAKKK1dC0iTU7kMy4to2HmMf4v9ke/8vypN2KjFydkXfDOiJd/6ZdDMKthIyOHI7n1H8z9Oek1TU4NLtvNl+ZzwkYPLn/D3qeWSCzti8hWKGJfTAUdgB/SvP8AVNTn1S582X5UHCRg8IP8fesknN3Z6EmsPDljuyvdXEl3cyXEpy8jFj7ew9qioorY81u+oVa0r/kLWf8A13T/ANCFVataV/yFrP8A67p/6EKT2Kj8SPQbz/VD/eqnVy8/1Q/3qp1NPY3xf8QKKKKs5gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDnfFFlsuEvo1wk/D4HAkHXtjkc/XNYVd7Nb295A9tdnbC+CXGAUI7gkHHcfQmoIrLw3YMgZknkUE7nJkBznqB8v6Voo82otdkjia0bXRtWkmHk2dwjp8wZh5eMehOOa6f8A4SPTrOPZaWgjyclMLGPrxnngVVn8Yvu/cwxgDs2WJP14p8kVuyuWXY39NW7ezik1GKNLtQVJUgkj144GcDgccD6C80Ec4TzY0fYwddyg7WHQj3rz6fxNfSgL58mOuVwh/QUtprt95gK3cwcZwGcsD+B4pzamkkzWk+XRs6jxHcazHE8WmWb+Vtw86kFznH3QDn8cfljNcDPbT2zhLiGSFyMhZFKnHrzXQxeL9Rt2ZZwkhOMblHH0xirsPjdfKHnWql+5Vyo/LB/nWHLJDlyye5xlFd2NV8N3ryLNaRIZASztCuWJ68rk596ibRvDF4gaG5+zhSQcS7S3Ts+f0o1W6J9m+jOJors38DwytvttRYQsAV3RhzjHqCM/lWZP4N1WJAyeROc42xyYI9/mAFLmRLpyXQ5+itGfQdVt3CPYTkkZ/drvH5rkVWtrVptQitHzE7yiJty8qSccj2p3RNmeh6Kqaf4Ytmkk+RYfOZsdAcuePbNcroWkyalctqmoMFtlcyMzgASnOT7bfX8vp22pW5u7SS380xiQbWYAE7T1HPqMj8a5zWLPUNRMen6fEYbCEBC0mVDEDjryVHGDjr69a4lO8mk7HU4baXsYPiDWZNUuiqti1jY+Wo/i/wBo+5/T885NdKND0ywkCahePPcYDfZ7dSSSBkqcZPPb7v8AhtWQtrNP9EsI7c9AW5cjqQT9fc9B+HTGSStBGUo63mzlbPw7qd2Ri3MK5ILTfLjj06/pWxbeFbODDX100rDBMcQwMjqCep/StZ5pJPvOSPTtUdPlk939xPNBbL7yS3FtYxmOwt0hU9T1Y/U9+p65qOiiqjFR2JlJy3CiiiqJCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArltUiWfxJ5LEhZHjUkdcEKK6msVVUeKrieR9qW8XmNxnjYB/WtaceZ280JmVrs/n6tOQW2odgDdscHHtnP507w9/yGrf8A4F/6Caz5JGlleSQ5dyWY+pNaHh7/AJDVv/wL/wBBNOMuaqn5h0K2pf8AITuv+uz/APoRq94ZlVdRaBwWSeMqV6qT15H0B/OqOpf8hO6/67P/AOhGjTrj7LqEExbaquNxxn5eh/TNKMuWrfzDoQzxNBPJCxBaNipI6ZBxU2m/8hO1/wCuyf8AoQqz4gt/I1abC7VkxIvOc56n881W03/kJ2v/AF2T/wBCFLl5alvMOh6Qn3F+leXV6in3F+leXVgvikd2K+GH9dgoooqziCiiigApUVndURSzMcAAZJNJXY+GdEe0/wBMuhiZlwkZHKA9z6H+Q+vEylZGtKm6krIseHtE/s2MzznNzIuCAeEHp7n3/wAm3q+pRaZZtIzDzWBESddzf4etT317BYWzT3DbUHQDqx9B7155fXs9/ctPcNuc9AOij0HtWUU5O7O6rUjQjyR3I555bmd5p3LyOcsx71HRRW55m4UUUUAFWtK/5C1n/wBd0/8AQhVWrWlf8haz/wCu6f8AoQpPYqPxI9Jri/GX/IWi/wCuA/8AQmrtK4vxl/yFov8ArgP/AEJqxp7np4v+GYFFFFbnlBRRUkEEtzOkMCF5HOFUd6A3JtNsZNRvUtozt3cs2MhQOp/z3xXoNrbwafZLCh2wxKfmc/iST+ZqDSNNi0yzWNVHmsAZX67m/wAPSsPxRrTb2sLWQbcYmZTzn+7/AI/l61i3zuyPShFYeHNLcz/EWsjU51jgyLeInaTkbz64/l+PriseiitUrKx585ub5mFFFFMkKtaV/wAhaz/67p/6EKq1a0r/AJC1n/13T/0IUnsVH4keg3n+qH+9VOrl5/qh/vVTqaexvi/4gUUUVZzBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABVa7sLe7UiVOT/EvBqzRQNOxy97oFxBloD5yeg+9+VZUkbxOUkUqw6giu9qC6s4LtNs8Yb0PcfjQGhw9AJByODW5eeHZVbNq4dSfuscEVjTQyQPslRkb0IoCxaQrdRbWP7wf5zVN1KMVPUUKxVgynBFW/lu07LIv+fyq/i9S/j9SnTldlGFYgexpGUqxVhgikqNjMmju543VkkIZSCCOox71o2/iXVIC2Ll2Df3ju/wDQs1kUU7t7lKTXU6eHxrepGFkjidh/EV5P5ED9K1YPGMMhBe0ZY+csr5I/Agfzri4bcFfMlO1Bz9akRZ7+QQW0Zx3+nv6VXs42vJGinJLU6bUPGcYLLZW7M3ZpTgA/QdfzrPSXWNby01y0Fs2RhRtBB7YHLD6n1qfTtDitsSXGJZR0H8I/xrWrJU4R2RMqknpcrWVhb2KbYU5PVjyx/GrNFFUZhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVj3/8Ao6atc/u90gjhTd15Ubsfgc/h7VsVieKSI4II1UATOZHPckKFH6GtqWik+3/DCZzdaXh7/kNW/wDwL/0E1m1peHv+Q1b/APAv/QTU0vjj6oHsVtS/5Cd1/wBdn/8AQjVarOpf8hO6/wCuz/8AoRqtUy+JjNvxB/pFvY3w5Mse1yv3QeuPrkt+VZum/wDITtf+uyf+hCtL/j48Jf3fs0313ZP6ff8A0rN03/kJ2v8A12T/ANCFbT1mpd7CWx6Qn3F+leXV6in3F+leXVyL4pHdivhh/XYKKKKs4goorf8ADOjfbJftV1Fm2T7gbo7fTuB/P8aTdlcuEHOXKiz4X0Vt6391GNuMwqw5z/e/w/P0rp554raB5p3CRoMsx7U52VEZ3YKqjJJOABXA63rMuqT4GUt0PyR/1Pv/AC/nik5s9GUo4eFluQ6pqc+qXPmy/Kg4SMHhB/j71SoordKx5jbk7sKKKKBBRRRQAVa0r/kLWf8A13T/ANCFVataV/yFrP8A67p/6EKT2Kj8SPSa4vxl/wAhaL/rgP8A0Jq7SuL8Zf8AIWi/64D/ANCasae56eL/AIZgUUUVueUFd14d0Y6ZA0k+DcSgbgMHYPTP8/w9M1Q8L6Kuxb+6jO7OYVYcY/vf4fn6VsazqaaZZNL8pmbiNGP3j/gOv/66ynK+iO/D0lBe0mUfEmtLZwNaW8h+1OOSp/1Y/wASP8fSuKqSeeW5neady8jnLMe9R1cY2Ry1qrqSuFFFFUZBRRRQAVa0r/kLWf8A13T/ANCFVataV/yFrP8A67p/6EKT2Kj8SPQbz/VD/eqnVy8/1Q/3qp1NPY3xf8QKKKKs5gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACo57eG4TZNGrr7ipKKAMC78OclrWTjH3X/xrGnt7izlxKjIw6Hsa7imyxRzIUlQOp7EUx3OO+W7Tssi/5/KqhBUkHqOK6a58PxE77SQxPnODyKyr2wlTBkTZJj8G/Gq+L1La5ldbmbVqKBUXfMPov+e9W9O02WUhgvJ6sei1v2mnQWzCTG+bGN7dvoO1Ukoay3J+HcybXRp7orJeHyouojH3vx9P89K3oIIreMRwxqijsB/nNPorNtvVkt3CiiikAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABWN4j02e4aO6gUybUCMijLdTyPXrWzTlcr9K1pOOsZ7MTPPq0vD3/ACGrf/gX/oJrb1fQ4rtHntFCXGdxGcB/8D/k+tY+iQyW/iCGKZCjqWBB/wB01apOFSPa61C90U9S/wCQndf9dn/9CNVqs6l/yE7r/rs//oRqtWMviYzc8Os00F9ZAndLESmT8oOMH+Y/KszTf+Qna/8AXZP/AEIVZ8P3HkatDltqyZjbjOc9B+eKc8H2bxMsWFAFypAXoASCB+RrZawi+zsI71PuL9K8ur1FPuL9K8urkXxSO7FfDD+uwUUVpaJpL6rcld2yGPBkYdeegHucGqbsckYuTsiXw9pH9pXJeZW+zR/eI43H+7n/AD+GRXdIqoioihVUYAAwAKbBBFbQJDAgSNBhVHauV8S660jyWFqSqKSsr9Cx7qPb19fp1xd5s9JKOHhd7lbxFrb3srWsB22yNgkH/WEd/p6fn9MOiitkrKx505ub5mFFFFMgKKKKACiiigAq1pX/ACFrP/run/oQqrVrSv8AkLWf/XdP/QhSexUfiR6TXF+Mv+QtF/1wH/oTV2lcX4y/5C0X/XAf+hNWNPc9PF/wzArc8O6I97Kt1ONtsjZAI/1hHb6ev5fSpomltql55ZYpEg3SMB29B7n/AB9K7yKOCztgkYWKGJfXAUdyT/WrnK2iOXDUOZ80tht9ewWFs09w21B0A6sfQe9ee6hey6heSXEpPzH5VJztXsBVrW9Zl1SfAyluh+SP+p9/5fzzKcI2JxFb2jstgoooqzmCiiigAooooAKtaV/yFrP/AK7p/wChCqtWtK/5C1n/ANd0/wDQhSexUfiR6Def6of71U6uXn+qH+9VOpp7G+L/AIgUUUVZzBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUjKrqVdQynqCMilooAAAoAAAA4AHaiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAHKxU8UGGGWZJ2jUyp91scjgjr6cmm0oODkVvSruno9UJq5x+t2k1tqMzSr8srs6MOhBOfzrPr0GRI7mJoZkDIwwVPeuU1XQprH95Dumh5JIHKfX2x3/lVVKV1zw1QJ9GZkErQTxzKAWjYMAemQc1v6rCo8QWFxGAUnZDvByGIYf021ztdNt+06fo1yFYGKZIyByAM4yfxUfnSo6px9GDOrT7i/SvLq9RT7i/SvNrGynv7lYLddznqT0Uep9q5F8UjvxKbUEv62JdL0yfVLnyovlQcvIRwg/x9q76xsoLC2WC3Xag6k9WPqfeotL0yDS7byovmc8vIRy5/w9qoeINdXT0NvbkNdMPqIx6n39B+P1zbcnZGtOnGhDmluQeJNda1LWVoSs2P3knTYCOg98d+316cfSuzO7O7FmY5JJySaStYxsjgq1HUldhRRRVGYUUUUAFFFFABRRRQAVa0r/kLWf8A13T/ANCFVataV/yFrP8A67p/6EKT2Kj8SPSa5PxLZT3+vwQW67nMAyT0Ubm5PtXWUwRoJWlA+dlCk56gZx/M1zxdtT2KtP2i5WQafZRafZx28QHyj5mAxubuTXLeJtaW8cWlrITAh+dgeJD/AID9fwBrR8Ta29p/odqcTMuXkB5QHsPQ/wAh9eOUhs7q4QvBbTSqDglELDP4VpCP2mcmIq/8u4ENFXYtI1GWQItlOCf7yFR+Z4qx/wAI5q3/AD6f+RE/xrS6ONU5vZMyqK3k8JagyKxkt1JGSpY5HtwKnh8HzMhM94iNngIhYY+pxS54lrD1H0OaorrIvB0YkBlvWZO4WPaT+OT/ACqx/wAIjYf89rn/AL6X/wCJpc8S1haj6HF0V3qeGtKVFU2xYgYLGRsn34NTQaJpkG7ZZxHd13jf/wChZxS9oi1g59WjzyrWlf8AIWs/+u6f+hCu9Sz05HV0trVWU5BCKCDVgzxqcFx+HNHO30GsNGLu5IjvP9UP96qdWbmVHjAVsnPpVanBWRliZKVS6YUUUVZzhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABUiP2b86jorSnUlTd0Jq5jat4dD5msBhycmLIA/4D6fT/wDVR4cXzbKe1bckkU6SNkehBx9fkNbiPjg9KFgiE7XCriR1CsQT8wHTI6Z967aUYTlzw07ol3RfT7i/Ss7RNJTSrYru3zSYMjDpx0A9hk1op9xfpTq8eb95nuximovsZet6zFpcGBh7hx8kf9T7fz/lwk88tzO807l5HOWY966y88Ly3t1JcTagN8hycQYA7Afe9Kk/4RGw/wCe1z/30v8A8TVRcYnJVp1qr20OLoruofDGmRIVeN5jnO53IP04xU0WgaXFIHW0Ukf3mLD8icU/aIzWDn3R5/RXpH9mWH/Pjbf9+l/wqwPLiVUG1FUYCjgAUvaeRX1O28jzSC1uLnd9ngll29diFsflU6aVqDuqiyuMscDMZA/M9K9DM0ajJcfhzSfaIv736GjnfYPq9NbzOG/4RzVv+fT/AMiJ/jU8XhTUXjDM0EZP8LOcj8gRXX/a4/RvypDdjPCEj3NF59g9nh1vI5mDwfcNu+0XUSemxS+fzxU6eDlDqXviVzyBFgkfXNbrXbfwqB9eaabqTHRR+FHvhfDLpf7zN/4RGw/57XP/AH0v/wATVq18O6datG6xM8kbBhIznOQcjpgfpU32iX+9+gpplkJzvb86OWXcPbUVqomjSEgDJIA96zSxY5Ykn3pKPZ+ZTxvaJo+ZH/fX86b9oi/vfoaoUU/Zoh4yfRF03UYPG4+4FNN2uPlUk+/FVKKfs0Q8VUZaN3xwnP1pv2uT0X8qr0U+SJDxFV9SY3EufvY/CmtNI3Vz+HFR0U+VEOpN7tji7kYLMR7mm0UUyW29wooooEFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFOVitNoqoycXdAWxdIEAw2QKT7X/sfrVWis3FN3Z0fWalrJlg3b54VQPemtcyHoQPoKhoo5UQ69R9SUzykYLn8Kb5kn99vzplFOyJc5Pdik5OT1pKKKZAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAH//2Q==", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_28cdb449c5ad4da7958d7b5c08e3efe4" + } + }, + "687d435e027b48e984eb2789ad6f2d03": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "6897285225264a61a60351eb926c2b31": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "6b08c8cf4c0046aa99e174fcb251a576": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "71edaa99e18f4145b2b988e1a2963fb9": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_747776a93eb041ae85ec7aee3c06b451" + } + }, + "7239f0f8f3f64b128c986fbd360a309a": { + "buffers": [ + { + "data": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdASFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2P/2wBDARESEhgVGC8aGi9jQjhCY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2P/wAARCAIABAADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwBKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKcqlqqMXJ2QDaKti1QoDlskUn2T/b/Ss3JJ2Z0fVqlrpFWirBtHzwyke9Na2kHQA/Q0cyIdCouhDRUpglAyUP4U3y5P7jflTuiXCS3QyilIwcHrSUyAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKkRO7flWlOnKo7ITdhETPJ6VKBgYFFFerSoxprQhu5aT7i/SnU1PuL9KdXz0/iZ9BD4UFFFFSUFFFFABTSiscsoJ9xTqKAaT3IzDGwwUH4cUn2eL+7+pqWindkOnB7pFf7JH6t+dIbQZ4cge4qzRT55EPD030KjWjfwsD9eKabWTHVT+NXaKftGQ8LTKH2eX+7+oppikBxsb8q0aKftGQ8HDo2ZhUqcMCD70lalIQCMEAj3p+08iHgu0jMorR8uP+4v5U37PF/d/U0/aIh4OfRlCirptYyeNw9gaabRcfKxB9+aftEQ8LURUoq0bTjh+fpTfsknqv50+eJDw9VdCvRUxt5c/dz+NNaGReqH8OafMiHTmt0yOinFHAyVYD3FNpktNbhRRRQIKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKCQoySAPU0AFFAIIyORRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABSgZOBSqpY8VKqhRXRRoSqa9BN2EVNvPenUUV6kIKCtEgKKKKoRaT7i/SnU1PuL9KdXzM/iZ9DD4UFFFFSUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAM8uP+4v5UhgjY5KD8OKkoouyXCL3RUuYkSMFVwc+tVquXn+qH+9VOt4O6PLxMVGpZIKKKKs5wooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiimvIkYy7AU0m9ENJvRDqR3VFyxAHvVOS9J4jXA9T1qs7s7ZYkn3rqhhZP4tDqhhZP4tC5JegcRrk+p6VVd3kOXYk00CiuhU4Q+FHfSoRp6pD45XiOVP4HpV6G5SU4+63oazqCM1lVoqWq3Crh4VNdma1FUIbx0OJfmX171eR1ddyEEe1cTTWjPLq0Z0nqLRRRSMQooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACnKhb6U2p1+6PpXThqSqS16CbsAAAwKWiivVSS0RmFFFFABRRRQBaT7i/SnU1PuL9KdXzM/iZ9DD4UFFFFSUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAFe8/1Q/3qp1cvP9UP96qdb09jysX/ABAoooqzmCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiio5Z44vvHJ9B1pqLk7Iai5OyJKZJMkQ+dufTvVKW7kfhfkHt1/OoCSTknJNdcMK3rI64YVvWRZkvHY/uxtH5mqxJY5Ykn1NJRXZCnGHwo7IU4w+FBTgKQClolLojaK6hRRRUFhRSgEkADJPQCpktJ3ziJuPXj+dJtLcCAjNCs8TbkODVxdOnK5JRT6E1L/Ziry8pK+gXFc9T2c+uoOzVmRwXiv8smFb17VZqnLYgE+W/4NTUM9twVLIM8D/PFcV1exw1sFf3qf3F6imRTJMMqefQ9afTPNlFxdmFFFFAgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAqdfuj6VBU6/dH0rtwfxMmQtFFFeiQFFFFABRRRQBaT7i/SnU1PuL9KdXzM/iZ9DD4UFFFFSUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAFe8/wBUP96qdXLz/VD/AHqp1vT2PKxf8QKKKKs5gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAPIwec0xraFjkxj8OKcaep4r18PT5IWe51qLhHQqtYIR8rsD781G1g4PyupHvxV+it7FKtNdTKa2mUZMZ/DmhLWdyAIn59RitWrC8KB7VzV6jppWOqhNzbuZKafO2chV+p6/lUq6W235pQD6Bc1pUVxOtNnUVE06BTk7m9if8KlS1gQYES/iM/zqaioc5PdgIAAAAMAdAKWikJwMmpACQBk1CzFjzQzFjzSVtGNgGP1ptPfpTK46ytM0jsMeJHbdjDf3gcGnrkDBO73oorNSaM6lGFRe8haKSirU+5wzwH8j+8Wigc0VaaexwVKU6btJBRRRTMwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKnX7o+lQVOv3R9K7cH8TJkLRRRXokBRRRQAUUUUAWk+4v0p1NT7i/SnV8zP4mfQw+FBRRRUlBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBXvP9UP96qdXLz/AFQ/3qp1vT2PKxf8QKKKKs5gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACg0Uhrow9Pnnd7I1pR5pBSr1pKB1r1DsaurElFFFWc4Dk4qzVdOWH1qxXn4x6pHbhVo2FFFFcR1hRRSE4GTQAE4GTULtuPtQ7bj7UlbwhbVgFFFFWAh5FR1LUR61y4hbMuIUUUVylBRRQBk4oAeg70h608cCmt1pUpe8efjY80ObsNooorpPJCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAqdfuj6VBU6/dH0rtwfxMmQtFFFeiQFFFFABRRRQBaT7i/SnU1PuL9KdXzM/iZ9DD4UFFFFSUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAFe8/1Q/wB6qdXLz/VD/eqnW9PY8rF/xAoooqzmCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooADSUGivWoU+SFup3U48sQooorY0Hr0paavWnVSMJqzHR/fFT1DF94n2qavNxTvUO7DK0AoopK5ToConbceOlDvu4HSm1tCNtWAUUUVoAUUUUAFMfrT6a/SsqyvAcdxlFFFcBoFPQd6YBk4qWom+gmwpG6UtFZxdncxqR54uJHRS0ld54AUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFTr90fSoKnX7o+lduD+JkyFooor0SAooooAKKKKALSfcX6U6mp9xfpTq+Zn8TPoYfCgoooqSgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAr3n+qH+9VOrl5/qh/vVTrenseVi/4gUUUVZzBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUGikNdGHp887vZGtKPNIKKKK9Q7QooooABwakqOnryKaM6i6k0XQmpKZF938afXlV3eozuoq1NCVE77uB0pXfPA6UyiEerNQooorQAooooAKKKKACkboaWik1dWAiooPWgDJxXmPQ1HoO9OoorBu7uQwooopCGN1pKc1Nrtpu8UeJiIclRoKKKKswCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACp1+6PpUFTr90fSu3B/EyZC0UUV6JAUUUUAFFFFAFpPuL9KdTU+4v0p1fMz+Jn0MPhQUUUVJQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAV7z/VD/eqnVy8/wBUP96qdb09jysX/ECiiirOYKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAA0lBor1qFPkhbqd1OPLEKKKK2NAooooAKclNpRwaYpK6LUfCCmO+eB0odsAKD9aZXmWvJyZ3RVopBRRRVFBRRRQAUUUUAFFFFABRRRQBG3WnIOM0MMkU6vLxHuyaKvoFFFFc4gooooAQ9KZUlMPWuig90ebjo6qQlFFFdB54UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVOv3R9Kgqdfuj6V24P4mTIWiiivRICiiigAooooAtJ9xfpTqan3F+lOr5mfxM+hh8KCiiipKCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigCvef6of71U6uXn+qH+9VOt6ex5WL/AIgUUUVZzBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBq28nmwhu44b61JWfYy+XNtPR+Px7VokdxXZTlzISlZ2YlFFFaFhRRRQAUUUUASjkCikX7opa8+Ss2juTurhRRRSGFFFFABRRRQAUUUUAFKBk0KufpUnSolK2wmyNxgAU2lc5akry6suabYBRRRWQBRRSE4pgBOKxpX3ys3PJzzWlcttt3PXjH51lV6GFhZNmOI0tEKKKK7DlCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACp1+6PpUFTr90fSu3B/EyZC0UUV6JAUUUUAFFFFAFpPuL9KdTU+4v0p1fMz+Jn0MPhQUUUVJQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAV7z/VD/AHqp1cvP9UP96qdb09jysX/ECiiirOYKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACte2l86EMeo4P1rIqzYy+XNtPR+Px7VpTlZkyV0aJHcUlPppHpXZcIz6MSiiig0CiiigB6fdp1Mj70+uKorTZ2U3eKCiiisywooooAKKKAM0AFPVe5pVXH1paylPsS2FFFI3Cms27K4iI8nNFFFeaUFFFJSAKaTmgnNFaxjY1jGxT1BvlROOTk1Rqe7ffcNzkDgVBXqUo8sEefWlzTbCiiitDIKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKnX7o+lQVOv3R9K7cH8TJkLRRRXokBRRRQAUUUUAWk+4v0p1NT7i/SnV8zP4mfQw+FBRRRUlBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBXvP9UP8AeqnVy8/1Q/3qp1vT2PKxf8QKKKKs5gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKANe2l86EMeo4P1qWsyxl8ubaej8fj2rTrrpy5kYyVmNI7ikp9NI7itEy4T6MSiiimajk60+o0+9UlclZe8dVJ+6FFFFYmoUUU5Vz16Um7AIATTwAOlL0orKUrkt3CiiipEFMk6AU+o5D81Y1naAIbRRRXCUFNJoJ7UlaRj1NIx6hTWYKpY9AM06q965W3IH8RxW0VzSSKnLli2ZxJJyTkmkoor0zyQooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKnX7o+lQVOv3R9K7cH8TJkLRRRXokBRRRQAUUUUAWk+4v0p1NT7i/SnV8zP4mfQw+FBRRRUlBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBXvP9UP8AeqnVy8/1Q/3qp1vT2PKxf8QKKKKs5gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACte2l86EMeo4P1rIqzYy+XNtPR+Px7VpTlZkyV0adFFFdZkNI7ikp9NI7ihM0hPoxF+8KlqKpa5661TO6i9GFFAGTUirj61yykkbN2EVfWnUUVk22QFFFFIAooooAKhJyTUrHAJqKuXEPZDQUhOKCcU2sIxvqaRjfUKKKK1NQqhftmRV44FX6yZn3zO2cgnj6V0YeN5XObEytG3cjooortOAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACp1+6PpUFTr90fSu3B/EyZC0UUV6JAUUUUAFFFFAFpPuL9KdTU+4v0p1fMz+Jn0MPhQUUUVJQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAV7z/VD/eqnVy8/wBUP96qdb09jysX/ECiiirOYKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA17aXzoQx6jg/Wpay7OdYZDvYKhHJPQe9TS6xp8LBWukJIz8mWH5iuuErrUzcHfRF6isKXxPbhR5NvK7Z6OQox+tVZfE9wWHk28SLjo5LHP6VXMi1Qm+h0pHcVKoLAVw0usahMoVrpwAc/JhT+YpkeqahE4dLybI7M5YfkeKxqe+rI6qUJQWp34AHSlriofE2oxbt7RzZ6b0xj8sVcj8XSCMCWzVn7lZNo/LB/nXM8PM0udTRWND4n06RyH82IYzudMj6cZq5Dq+nTIWS8iABx87bD+RxWTpyW6C5dopFZXQMjBlYZBByCKWpGFFFFADZD8tRE4p8h5qInNcVT3plxjcDzRVW4v7a2bY75kwcRoNzdM9B0/GojqDMPli288bjk/p/jW0aE2r20LlUhDdl+opLiKPq4z6Dms55pJPvOSPTtUdbRw38zOaWK/lRckvieI1wPU9ap0UV0RhGOxzznKe4UUUVRAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFTr90fSoKnX7o+lduD+JkyFooor0SAooooAKKKKALSfcX6U6mp9xfpTq+Zn8TPoYfCgoooqSgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAr3n+qH+9VOrl5/qh/vVTrenseVi/4gUUUVZzBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABUFxZw3HLrhv7y8Gp6KBptbGJcabNDyn71f9kc/lVMgqSCCCOCDXT1FPbQ3AxIgJ7MOoq1PubRrPqc5RWhPpUqHMJEi+h4IqgysjFXUqw7EYNWmmbqSlsNIpKdSEVpGXQUl1EooorQgVWZHDIxVlOQQcEGrsOs6jBu2Xch3dd53/zziqNFS4p7gbUfijUEjCssMhH8TIcn8iBV+LxajSAS2bKncq+4/lgfzrlwCTgVPBA8jbY13NRHDQnq1ZA5WOgu/EoYn7NAeR1kPQ/Qf41SE+oajkyTNHCc/d4H0wOv406105I/mmw7en8NXazfsKWlKOvdmcqsnoRQW0duuEHPdj1NS0UVhKTk7sxCiiikAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVOv3R9Kgqdfuj6V24P4mTIWiiivRICiiigAooooAtJ9xfpTqan3F+lOr5mfxM+hh8KCiiipKCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigCvef6of71U6uXn+qH+9VOt6ex5WL/iBRRRVnMFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUyaCKddsqBh+op9FAbGTPpLAkwOGH91utUJInifbIpVvQ10tNkiSVNsihl9DVqb6m0azW5zBFJWxPpKkEwOVP91ulZk8EsDYlQr/I1vCaehpeMtiKlVSxqe1tJblvkGF7selbVtZRW2Co3OP4jVucY/ERKaRRtdMZsGX5F9P4jWpHGkS7Y1Cj2p1Fc9SrKpvsYtthRRRWQgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACp1+6PpUFOVyv0rpw1VU5a9RNXJqKQEEZFLXqpp6ozCiiigAooooAtJ9xfpTqan3F+lOr5mfxM+hh8KCiiipKCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigCvef6of71U6uXn+qH+9VOt6ex5WL/iBRRRVnMFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABSMqupV1DKeoIyKWigAACgAAADgAdqKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAcrFTxUqsGFQUoODkV0Ua8qenQTVyeimq+7jvTq9SE1NXiQFFFFUItJ9xfpTqan3F+lOr5mfxM+hh8KCiiipKCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACimeZH/fX86QzxqcFx+HNFmS5xW7I7z/AFQ/3qp1ZuZUeMBWyc+lVq3grI8vEyUql0woooqznCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACpEfs351HRWlOpKm7oTVyxRUSPjg9KlByMivVpVo1FoQ1YtJ9xfpTqan3F+lOr56fxM+gh8KCiiipKCiiigAooppdVOGYA+5oBtLcdRUZmjUZLj8OaT7RF/e/Q07Mh1ILdoloqv9rj9G/KkN2M8ISPc0+SRDxFNdSzRVRrtv4VA+vNNN1Jjoo/Cn7NkPFUy7RVD7RL/AHv0FNMshOd7fnT9myHjIdEzRpCQBkkAe9ZpYscsST70lP2fmQ8b2iaPmR/31/Om/aIv736GqFFP2aIeMn0RdN1GDxuPuBTTdrj5VJPvxVSin7NEPFVGWjd8cJz9ab9rk9F/Kq9FPkiQ8RVfUmNxLn72PwprTSN1c/hxUdFPlRDqTe7Y4u5GCzEe5ptFFMltvcKKKKBBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABTlYrTaKqMnF3QFsXSBAMNkCk+1/7H61VorNxTd2dH1mpayZYN2+eFUD3prXMh6ED6CoaKOVEOvUfUlM8pGC5/Cm+ZJ/fb86ZRTsiXOT3YpOTk9aSiimQFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB//9k=", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_0e971676622b4e24b3b7b4a4bbf82af8" + } + }, + "747776a93eb041ae85ec7aee3c06b451": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "74bbe62a9d604bc1902ed8de1ede91da": { + "model_module": "ipycanvas", + "model_module_version": "^0.13", + "model_name": "CanvasManagerModel", + "state": { + "_model_module_version": "^0.13", + "_view_module": null, + "_view_module_version": "" + } + }, + "763434d108c943ec963e572182f71412": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_c29eb1dd56b94eac8a8d79fd36b76504" + } + }, + "79e3ab585f4f4eba8404f11b9b8c4e5b": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_09357156e94142fe8abc1f70c30e70ec" + } + }, + "79f4ad25e79d42a9aa03fcba0d8b7830": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_08a6bc9e8c2441998aa15ebc4c69667d" + } + }, + "7ca0fb1e6ff74f7a86a69ccbd6c1bfea": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_dc65a72c8e16444f9527a674358775f8" + } + }, + "814e3b8b4bcf45cd908972a591dbdb4c": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_52219eab5a534c5eafd9e66fdc6c3f3c" + } + }, + "81f2351b03644df39e2c8dd4342c4097": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_c83af41cbb3542708293e7f95bfed76d" + } + }, + "82717cc25b2c44a4a70742d2ec263435": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_eddd2bdec793468ba5645a5eeb859468" + } + }, + "883050fc8e244613b62e9aee196b7ae4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "8d390a6198e14de3abb4c02f86eed6e8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "8f03211affc24281a3c755e1a413b5b7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "8fd21a1694e34e89aed7c2a8d9e706c4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "92e5a81bd5dc40139cb339813cb39d71": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_a7bd29798fd8472c9efb68a3dd2987cc" + } + }, + "94b84a1da7284751a57189c75db9083e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9548190091d34d27a44714164b565f8b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "972d52b3c02e41bdb136ed10f38bf44b": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "layout": "IPY_MODEL_6b08c8cf4c0046aa99e174fcb251a576" + } + }, + "9874e422848a4c65b459519e84d4f9b4": { + "buffers": [ + { + "data": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdASFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2P/2wBDARESEhgVGC8aGi9jQjhCY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2P/wAARCAIABAADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwBKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAopyqWqybRcfKxB9+aJe6k31NKdKVS/L0KlFWjaccPz9Kb9kk9V/Op54lPD1V0K9FTG3lz93P401oZF6ofw5p8yIdOa3TI6KcUcDJVgPcU2mS01uFFFFAgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoopaAEp6Jnk9KVE7t+VZGsa8lr5lva/PcDgt1VPX6n/PtXXToqC56v3Et9jVa5gjuI7ZnAlkBKp3IH8q0q4DQpHl16B5XZ3O7LMck/Ka7+sMXU9pGLt3/AEPQwKtzfL9TmYfGELORPZui44KOGOfocVP/AMJdYf8APG5/75X/AOKri6Kw5ImSxVTud9/wkek/8/f/AJDf/CpodZ02dCyXsIAOPnbYfyOK87opezRaxk+qR6ZDeWtw5SC5hlYDJCOGOPwqevLKKXs/MpY19YnqHlx/3F/KkMEbHJQfhxXnX9p3/wDz/XP/AH9b/Gp4dd1OBCqXjkE5+cBz+ZzRyS7j+s0nvE7w20ZHAI+hpptExwzZri4vE2qJIGadZAP4WjGD+WDVj/hLr/8A5423/fLf/FUcs+4e1w73idV9k/2/0pptHzwyke9YCeMWCKHsQWxyRLgE/TFTQeMLdt32i1lT02MHz+eKPfC2Gf8ATNdraQdAD9DSGCUDJQ/hVBPFuns6qY7hQTgsVGB78GrP/CR6T/z9/wDkN/8ACjml2F7Gg9pEnlyf3G/KmkYOD1qaLV9OljDrewAH+84U/keangure53fZ54pdvXY4bH5Ue0fVB9Vg9pFGitIorHLKCfcU0wxsMFB+HFHtEJ4OXRmfRV/7PF/d/U0z7JH6t+dP2iIeEqIp0VbNoM8OQPcU1rRv4WB+vFPniQ8NVXQrUVObWTHVT+NN+zy/wB39RT5l3JdGovssiop5ikBxsb8qaVKnDAg+9VczcWt0JRRRQIKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiinKpY8U0nJ2QCAZOBT2McCGSV1RR1ZjgCiV1treSVgSsaljjqcDNcVqeqz6kwEmEiU5WNen1Pqa7FGOHXNLWRO5e1jXmule3tQUhJwz93H9B/n2rDoorlnOU3eRSVjS8Pf8hq3/wCBf+gmvQa8+8Pf8hq3/wCBf+gmvQazq/BH1f6Hdgt5fL9TyyiiimcIUUUUAFFFFABRRRQAUUUUAFFFFABRRUkEEtzOkMCF5HOFUd6A3JLGynv7lYLddznqT0Uep9q77S9Mg0u28qL5nPLyEcuf8Pao9E0tdLs/LLB5XO6RgO/oPYf4+tS6pqEWmWZuJQW52oo/ib09ulYSlzOyPUo0VSjzy3LlFc74WvZ7+5v57htzny8AdFHzcD2roqlqzsb05qceZBXL6rqOraLeDdMlxBID5fmIB6dduOR+XP5WtL1pf7TurC6kO77Q4hZjxjd93/D8vSta+soL+2aC4Xch6EdVPqPemvdepnL97G8HZnJ/8Jdf/wDPG2/75b/4qrX/AAmX/Th/5G/+xrn9QspdPvJLeUH5T8rEY3L2IqtWvLFnn+3qxdrnYQ+L7VkJntpkbPAQhhj6nFTReK9OeQKyzxg/xMgwPyJNcTRR7NFLFVEd9/wkek/8/f8A5Df/AAqymq6e6KwvbfDDIzIAfyPSvOKKXs0WsZPqkenRTQXMZaGSOZM4JRgwzTvLj/uL+VeX0+KWSGQSRO0bjoynBH40vZ+ZX1tPeJ6X9ni/u/qaabWMnjcPYGvPf7Tv/wDn+uf+/rf41ZTxDqqIqi7OFGBlFJ/Mjmjll3F7ai94nbm0XHysQffmkNpxw/P0rkIPFOpxbt7RTZ6b0xj/AL5xUyeL70OpeC3K55ADAkfXNFphzYZ9DpXt3RCxK4HpUNX7n/UN+H86oVUG2tTLEU405WiFFFFWc4UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRTZJEiQvIwVR1JNY994gjjylqvmN03noP8AGmkNI2iQoyxAHqapz6jFHGZFIKAZ3np/9esSCSfUCZrxz5K8hein1/DiqmoXxuD5ceREP/Hq2UYxjzS+R0RhCEeefyOqgvI5FG4hc9Dng1YrirK8a1fBy0bfeX+orat72SJPMtm8+3HBixyv+6f6H8KhxUleIOnGouanv2/yNuioLS9gvIw8EgJxkqeq/UVPWZzBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFSImeT0q4QdR8sQbsNVC30qjqusw6dmJB5lxjIUdF9N3+H8qz9X8QfftrE+xmB/Pb/j/APrrnWZnYsxLMxySTkk10OpGiuWnq+5Nr7nbaTdtPpttJcPullLKDjGSC3p7CuOu4GtbqWBs5jYrkjGR2P41uwXH2XQtLmLbVW5+Y4z8uXB/TNVPFEHl6mJQGxKgJJ6ZHGB+AH51Vb3qafVW/FAtzHoooriKNLw9/wAhq3/4F/6Ca9Brz7w9/wAhq3/4F/6Ca9BpVfgj6v8AQ7sFvL5fqeWUUUUzhCiiigAooooAKKKKACiiigAooqSCCW5nSGBC8jnCqO9AbhBBLczpDAheRzhVHeu70TRotLgycPcOPnk/oPb+f8jRNGi0uDJw9w4+eT+g9v5/yuX17BYWzT3DbUHQDqx9B71jKV9EenQoKmuee/5BfXsFhbNPcNtQdAOrH0HvXA6pqc+qXPmy/Kg4SMHhB/j70apqc+qXPmy/Kg4SMHhB/j71Sq4xscteu6jstjqfBP8Ay+/9s/8A2auqrlfBP/L7/wBs/wD2auqrKfxHdhv4SPNtV/5C15/13f8A9CNdf4e1v+0ozBOMXMa5JA4cevsfb/I5DVf+Qtef9d3/APQjUME8ttOk0DlJEOVYdq1ceZHnwqunNvod9relrqln5YYJKh3RsR39D7H/AA9K4CWN4ZXikG10Yqwz0I616DpGpRanZrIrDzVAEqdNrf4elUPEmireQNd28Z+1IOQo/wBYP8QP8PSohKzszqr0lUj7SBxVFFFbHnBRRRQAUUUUAFFFFABRRRQB6dc/6hvw/nVCr9z/AKhvw/nVCs6ex14z416BRRRWhyBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRUNzeQWqFppAuO3esO+8Qu2UtF2jpvbr+A/Kq5XuyuV7s3priKBd0sioPc1i3viIDK2aZ/wBtx/T86wZZpZm3SyM5yTyaZRdLYLpbE091PcnM0rP9ansbLz/3svywrySeM/8A1qLCxNwwkkBEQ/8AHqk1G9V1+zwY8scEjvjsPatYxsuefyN4QSXtKny8yO+vfO/dQ/LCvpxu/wDrVSoorKUnJ3ZhObm7sKmtbl7WXcnIP3l7GoaKSbTuhRk4u6NfYlyPtVgxjuFOSM4Jq7Y698yw36GN+nmYwPxHaufgme3lEkZwR+R9q0v3WqQ9kuUH5/8A1v5VpZT23On3a22kvz/4J1COrqGRgynkEHINLXH293d6TOUB+XOSh+63uK6LT9Vt74BQfLl/55sev09ayOZpp2L1FFFAgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArO8SLIdHBTO1ZAXwccc/nzitGqF8RO13ZlXctaCRFHTIZv1zt/Kt6Ora7oTOPooorAZt3X/ACKVn/12P83qfVib/wAPWt7tLOhAdjx7Nx7sBUF1/wAilZ/9dj/N6n0NRfaLd2JyWByu4/KMjj9Rmu1avk7xRJztFFFcRRpeHv8AkNW//Av/AEE16DXn3h7/AJDVv/wL/wBBNeg0qvwR9X+h3YLeXy/U8sooopnCFFFFABRRRQAUUUUAFFFSQQS3M6QwIXkc4VR3oDcIIJbmdIYELyOcKo713eiaNFpcGTh7hx88n9B7fz/kaJo0WlwZOHuHHzyf0Ht/P+WhPPFbQPNO4SNBlmPasJSvoj06FBU1zS3/ACI769gsLZp7htqDoB1Y+g964HVNTn1S582X5UHCRg8IP8fejVNTn1S582X5UHCRg8IP8feqVaRjY5a9d1HZbBRRRVnMdT4J/wCX3/tn/wCzV1Vcr4J/5ff+2f8A7NXVVzz+I9fDfwkebar/AMha8/67v/6Eaq1a1X/kLXn/AF3f/wBCNVa3Wx5UviZa02+k069S5jG7bwy5wGB6j/PfFehWd1Fe2sdxCTskGRkYI7EfnXmdauhavJplyFZs20jDzFP8P+0Pf+f5VM431OjD1vZvlexpeJ9EcSSahbDch5lQD7v+0Pb1/P6cxXqH7ueL+GSORfqGB/mK4bxDpH9m3IeFW+zSfdJ52n+7n/P44NKEujLxNG3vx2MiiiitDiCiiigAooooAKKKKAPTrn/UN+H86oVfuf8AUN+H86oVnT2OvGfGvQKKKK0OQKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiig1UIuclFDiuZ2RBPdxQKScsR2UZ/lWDf69cMxjhQwD1YfN2/KtW+vrG0nSCeJgWAbcijAGSOec9qYs+k3O4LcqoAwQx2g/99da7PYQWilqb8tPZOzOUZmdizsWJ7k5pK6t9EtpkVkEbA8gqNoI/DrVSbw8MsUDDjjawI/XmolhKm61E6LezRz9W7C0NzKCwPlL949M+1XBoUnmIpZjk8jZgke1aR0yeS2MECGJcYOV7fjUxouLvM1o4aTfNJaL8THv74FTb25AjHBYd/Ye1Z1dLF4X+VS7nPcFuv5D+tWf7G0yzYG4ljTcCAHYDP/fRNRO8neTLnh6tR802kcjUy2dy7BRA+T6rgfrXUi60O1zF56nb/dBI/AqMVXk8R2MaqbeyZnB/jAXHvnnmotBdSPYUo/FMx4dHvJs4jxj3z/LNXYvDVwyqzMcdxgD+Z/pT5vFdyWHk28SLjo5LHP1GKoz67qUwZTcFFY5wgC49gev60XiugXw0ejZsReF41f8AePuX3b/ACrdro1hE7ojKZUOW2kZXI75yRXN2dve6zcLG00jqnLPIxYID9e/HSuoY2mjWG1fkiT8Wdv6n/PQVUZN7aHTRlGXvKNkuol1ptpPHteLOP4s81j3Ph1gxe0mwRyFbt+NbOnXf2+yWchQxLAqDnbzwPyxXN6q01hq0rQO8QkIkG1uG+o+uetRVvzXRVd0+RTlG/wCZdt9RvdPKx6lE7Rk4EvUj8eh/nW1b3EVzGJIJA6eornLfxFcRjE8aTDHUfKc/y/SrlveaXK+6Fms5TwCPk4HPPVfzrO7W5xeypz+CX3m3RTUYMoYMGB5BHQinU00zKpRnT+JBRRRTMgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKyri48jxNaZbaskPltxnOS2B+eK1a5zxDK0Gr20ygFo41YA9Mhia0py5Xf+txMybuJYLyeFSSscjKCeuAcVDWr4kRRqhlVw6zRq4I6Yxj8emfxrKpVI8smho27r/kUrP/AK7H+b1H4YnaLVBFyVmUqRngEDOf0I/GpLr/AJFKz/67H+b1kW0vkXMU23d5bhsZxnBzW0pcs4y8kIn1WD7NqdxFhQA5IC9ADyB+RqpW/wCKot0tvdo26N025AyPUc++f0rArKtHlm0C2NLw9/yGrf8A4F/6Ca9Brz7w9/yGrf8A4F/6Ca9BrKr8EfV/od+C3l8v1PLKKKKZwhRRRQAUUUUAFFFKis7qiKWZjgADJJoAEVndURSzMcAAZJNd14e0j+zbYvMq/aZPvEc7R/dz/n8cCo/D+hLp6C4uAGumH1EY9B7+p/D67E88VtA807hI0GWY9qxnK+iPSw9Dk9+W4TzxW0DzTuEjQZZj2rg9b1mXVJ8DKW6H5I/6n3/l/M1vWZdUnwMpbofkj/qff+X88yqhC2rMMRiOf3Y7BRRRWhyBRRRQB1Pgn/l9/wC2f/s1dVXK+Cf+X3/tn/7NXVVzz+I9fDfwkebar/yFrz/ru/8A6Eaq1a1X/kLXn/Xd/wD0I1VrdbHlS+JhRRRTJOi8M62lp/od0cQs2UkJ4QnsfQfyP146u6t47u2kt5RlJFKn29x715lXY+Gdbe7/ANDujmZVykhPLgdj6n+Y+nOU49Ud+GrX/dyOb1TTJ9LufKl+ZDykgHDj/H2qlXo2qaZBqlt5UvyuOUkA5Q/4e1eezwS207wzoUkQ4ZT2qoSujCvR9m9NiOiiirOcKKKKACiiigD065/1Dfh/OqFX7n/UN+H86oVnT2OvGfGvQKKKK0OQKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACsjW9SNpJBHHnduDuAcZUHp+P8AT3rVlkWKNpHOFUEk+gFcRd3DXV1JO/Bc5x6DsPyraL5I83Vmi92N+rN3xJAJbWG6jwwU7SVGcqehz6f41zldTY41LQfIO3cEMfcAMPu/0NctV4hXamuo6q1v3HRyPE4eN2Rh0ZTgirkGsX8GALhnGckSfNn2yeao0VhGUo7MzvY7nRLma8sxcTiMFidoTPTOOc+4NYF74ivWupPs0ypCGITag5GeCc98Vu6KBaaJG8zAKqGQkc4By38jXEVpWbcteyOuc5QpRSdrlie/u7gMJrmV1c5Klzt9enSq9FFYnI23uFFFFAgqeztJr64WCBcsepPRR6n2os7Sa+uFggXLHqT0Uep9q7C2t7XR7FgGAAGZZW6sf89BVRjc6KFB1Hd7DY1ttC00qXJUHLN3dj6D8P8APWuU1G/l1CfzJOFHCIOij/PepNW1BtRut4BWNRhFJ7ep9zVGnKXRbDr1ub3IfCjpfCsubaeHb91w2c9cjH/stQ+KYgHglCnJypbt6gfzqt4alWPVNpBzIhUY9ev9K2PEMHm6a5AYmMhwB+R/QmiWsU+x0w/eYZrt+mpyNFFFQeaSwXM1s26CV4zkE7Twceo71p2/iK4jGJ40mAHUfKc/y/Sseik0maQqzh8LOwttZsrgcTCNsZ2yfLj8en61fzXAV12j2w0/TjJMWUkeZJnPy8en061Enyq510uXENqUbea0NKkpW60lWndXOKceWTj2CiiimSFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVzPij/kIRf9cR/6E1dNXM+KP+QhF/1xH/oTVS2YCaovn6Jp10FVdoMLepxwPw+U/nWPWvZItz4dvIQhaSGQTA5wAMY/kGrIq6utpd1/wBI27r/kUrP/AK7H+b1iVt3X/IpWf/XY/wA3rEp1t16IEdHN/p3hKN+rwY4TttO3n/gJzXOV0XheVJoLqxlAKsN2OckEYbn8vzrn5I2ileOQYdCVYehFVW96MZ+X5AjQ8Pf8hq3/AOBf+gmvQa8+8Pf8hq3/AOBf+gmvQa5qvwR9X+h34LeXy/U8sooopnCFFFFABRRSorO6oilmY4AAySaABFZ3VEUszHAAGSTXbeH9CXT0FxcANdMPqIx6D39T+H1PD+hLp6C4uAGumH1EY9B7+p/D67TsqIzuwVVGSScACsZzvoj0sPh+X3pbjZ54raB5p3CRoMsx7Vwet6zLqk+BlLdD8kf9T7/y/nJ4h1f+0rkJCzfZo/ug8bj/AHsf5/DJrIqoQtqzDEV+d8sdgooorQ5AooooAKKKKAOp8E/8vv8A2z/9mrqq5XwT/wAvv/bP/wBmrqq55/Eevhv4SPNtV/5C15/13f8A9CNVatar/wAha8/67v8A+hGqtbrY8qXxMKKKKZIUqMyOroxVlOQQcEGkooA77QtXj1O2Cs2LmNR5in+L/aHt/L8qj8RaMdTgWSDAuIgdoOBvHpn+X4+ua4uzupbK6juISN8ZyMjIPYj8q9C02+j1GyS5jG3dwy5yVI6j/PbFYyXK7o9KjUVaPJPc84dWR2R1KspwQRgg0ldX4o0VdjX9rGd2czKo4x/e/wAfz9a5StYu6ucNSm6crMKKKKZmFFFFAHp1z/qG/D+dUKv3P+ob8P51QrOnsdeM+NegUUUVocgUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU2WRYo2kc4VQST6AVUY8zshxV3YxfEt5siS1U8yfM/0HT9f5VzlTXdw11dSTvwXOceg7D8qhp1Jcz02HJ3eht+GbjZPLbk8ONy5buPQfT+VU9btzb6pLwdsh8xST1z1/XNQ6dcC1v4ZjgKrfMSM4B4P6GtnxRDmKCcBflJQnuc8j8OD+dbr36DXYven6HO0UVJbxefcxQ7tvmOFzjOMnFcqV9DI7O4AtPDkiTMBtt/LyOQTt2j9a4iu08RSLHociscGQqq+5zn+QNcXWlX42dOI05V5BRRRWZzBUttA91cRwRDLu2B7e/0psEMlxMsUKF5HOAorsdM06HSbdmZlMxGZJT0Ueg9B/n6VGLbN6FF1X5Eltb2ujWLAMBgZllbqx/z0H9a5fVtUk1CXAykCn5E/qff+VLrGpvfzlVOLdD8gHf8A2j/nis6nJ9EaV66a5IbIKKKKg5Cazn+zXkM2WARwTt6kdx+VdxcxLNA8bEhXUqcdcEVwNdzYT/atPhlLbiyDccY+Ydf1zVrWLR6OBlvFnDUVc1aLydUuFznL7unrz/WqdQjglHlk4voFFFFBJf0Wz+13y7lzFH8z5HB9B+P8s1reJrvy4Es1PzSfO/0HT9f5e9WdHtV0/TjJMNrEeZISOQMdPXgdvXNcveXLXd3JO/Bc5x6DsPyrL4peh3z/AHFBR6yOt0abz9KgYlcoNhA7Y4H6Y/OrlYXha4BSe2JGQfMXjk9j/T863aqOl0c1XW0u6/LQKKKKsxCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK5nxR/yEIv+uI/9CaumrmfFH/IQi/64j/0JqpbMBvhx1e5ns5HKpcxFcAck/wD6t1ZLKyMVYFWU4IIwQataVP8AZtTt5cqAHAJboAeCfyNO1qLydWuV3bsvuzjH3uf61b1pryYupeuv+RSs/wDrsf5vWJW3df8AIpWf/XY/zesSnW3XogRpeH7jyNWhy21ZMxtxnOeg/PFL4hthb6rIVACygSAA+vX9Qazo5GilSSM4dCGU+hFdB4mVbizs71AArDHI+bDDI/kfzqo+9Sa7ah1M/wAPf8hq3/4F/wCgmvQa8+8Pf8hq3/4F/wCgmvQa5qvwR9X+h34LeXy/U8sooopnCFFFFACorO6oilmY4AAySa7bw/oS6eguLgBrph9RGPQe/qfw+rPDOjfY4vtV1Fi5f7gbqi/TsT/L8a3XZURndgqqMkk4AFYznfRHo4ehy+/LcHZURndgqqMkk4AFcT4g11tQc29uStqp+hkPqfb0H4/Q8Qa62oObe3JW1U/QyH1Pt6D8fpiVUIW1ZliMRze7HYKKKK0OMKKKKACiiigAooooA6nwT/y+/wDbP/2auqrlfBP/AC+/9s//AGauqrnn8R6+G/hI821X/kLXn/Xd/wD0I1Vq1qv/ACFrz/ru/wD6Eaq1utjypfEwooopkhRRRQAVe0jUpdMvFkVj5TECVOu5f8fSqNFDVxxk4u6PT4J4rmBJoHDxuMqw71x3iTRWs52u7eMfZXPIUf6s/wCBP+HpUfh7W/7NkME4zbSNkkDlD6+49v8AJ7WeCK5geGdA8bjDKe9YawZ6Xu4mn5nmFFX9Z0x9MvWi+YwtzG7D7w/xHT/9dUK3TuebKLi7MKKKKBHp1z/qG/D+dUKv3P8AqG/D+dUKzp7HXjPjXoFFFFaHIFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFY3iS7EdqLYYLynJ9lB/wAf61sOwRSzEBQMkk8AVxWoXRvLySY52k4UHsvato+5By6vT/M0Xuxv3K1FFFYmYV1cJOp6AUyWkKbcbsksvTJPrgfnXKV0Hhi4G2a3OMg+YvHJ7H+ldOGfvcr2ZrS35e5z9XNHi87VbZd2MPuzj05/pRq9t9l1KZAMITuXC4GDzx7Dp+FWfDcPm6srbseWpbp17f1rOEbVFF9yEvesa3i2RV0+CIn52k3AewBz/MVyldH4wkUy2sYPzqrMR7HGP5GucrOTu7m2Kf7xrsFPghkuJlihQvI5wFFNVWdgqKWZjgADJJrstI09NLs/MmCrcMuZHJyEHpn+f/6qErsmjRdWVug7TdNh0m2LMymcjMkh6KPQegrA1nV2vWMMBK24P0Ln1Pt7f5BrWsNesYYSRbg/i59T7e3+Rk1TlZWRtWrK3s6ewUUUVBxhRRRQAV1fhiUvpzRlgTG5AXuAef55rlK2/C0+y8lhJUCRMjPUkdh+BP5VdN2kdOFly1V5h4oi23MMu77ylcY9D/8AXrErqvEsG+w8wBcxsDk9cHjj8SPyrlai1tB4uNqrfcK0tEsReXe5/wDVRYZhgHJ7D+f5Vm12FhCmlaVum4KgvJz1b0649BUTlZBhaanO8tkVPE135cCWan5pPmf6A8fr/L3rmqluriS7uHnlxvc5OBgVFThHlRnXq+1m5GhodwbfVIjztkPlsAOuen64rsD1rgFZkYMpKsDkEHBBrvIZfPt4ptu3zEDYznGRmltL1Be9Tfk/zHUUUVZiFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVzPij/kIRf9cR/wChNXTVzPij/kIRf9cR/wChNVLZgY1bfiT999ivOnnw/c/u9+v/AAL9KxK2nVbjwrGygbrWUhiRzgnt/wB9L+VaU9Yyj/WgmLdf8ilZ/wDXY/zesStu6/5FKz/67H+b1iUVt16IEFdNbN9t8JTRlmDQgglufuncAPbGBXM1v+EpcXNxDt++gbOemDj/ANm/Snh37/K+ugMpeHv+Q1b/APAv/QTXoNcJpcH2bxOsGGAR3A3dSNpwfyru656ytBLzf6HfgvtfL9TyyiiimcIV13h3QPI23l6n73rHGf4Pc+/t2+vQ8O6B5G28vU/e9Y4z/B7n39u316dLWM59Eehh8Pb35jXZURndgqqMkk4AFcT4g11tQc29uStqp+hkPqfb0H4/Sx4k11boNZWhDQ5/eSdd5B6D2z37/TrzlVCHVkYmvf3I7BRRRWhxBRRRQAUUUUAFFFFABRRRQB1Pgn/l9/7Z/wDs1dVXK+Cf+X3/ALZ/+zV1Vc8/iPXw38JHm2q/8ha8/wCu7/8AoRqrVrVf+Qtef9d3/wDQjVWt1seVL4mFFFFMkKKKKACiiigArqPC+tNvWwupBtxiFmPOf7v+H5elcvRSaurGlOo6cuZHpOoWUWoWclvKB8w+ViM7W7EV59fWU9hctBcLtcdCOjD1HtXXeHdbS9iW1nO25RcAk/6wDv8AX1/P6WNd0iPU7Ysq4uY1PlsP4v8AZPt/L86yi+V2Z3VYKvDnhucDRSurI7I6lWU4IIwQaStjzT065/1Dfh/OqFX7n/UN+H86oVnT2OvGfGvQKKKK0OQKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoopHYIpZiAoGSSeAKqEXKSSHFczsZHiK98m2FujfPL1wei/wD1/wDGuYqzqF0by8kmOdpOFB7L2qtVVJKUtNkVN3emwUUUVmQFXNKuPs2owuThSdrfNgYPHP06/hVOinF8rTQ07O50HiiDiC4C+qM2fxA/nTfCUO67ml3fcULjHXJz/wCy1enA1TQiwALsm8YXPzDqAPwIqPwjDiGebd95guMdMD/7KuypH95zrZq/4HQo3rLzKPiuRX1UKpyUiCt7HJP8iKxlVnYKilmY4AAySa0NcYXGuXAhy5LBAAOSQACPzFb+i6OunIJ5wGumHA6iMeg9/f8AyeNK70H7KVarK21xNG0hdPQTTgNdMPqIx6D39/8AJzdc1nzt1rat+76PIP4vYe38/p1Nc1rzi1tat+76PIP4vYe38/p1wqttJWRdatGMfZ09gooorM4gooooAKKKKACrmjy+Tqts23OX24z68f1qnRTTs7lRlytM7u+h+0WksWFJdCBu6Z7frXCV3sMvn2sU23bvQPjOcZGa4y/gaPUpoVjwTIdqKOxPGMexFOorT9TvxsbqMkWdAtPtN8JGHyQ4Y/Xt/j+FXvE15gJZRt/tyYP5D+v5VfsIU0rSt03BUF5OerenXHoK5O4ne5neaQ5dzk+3tWC96V+xNT9zRVPq9yOiiitTgCus8OzrLpYjGA0LEEZ5wec/r+lcnW14YuBHeSQMQBMvHHOR/wDWzUT2v2NqOsuXvp/XzOloooqzEKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArmfFH/IQi/64j/0Jq6auZ8Uf8hCL/riP/QmqlswMatrQ1FzY6hZHLM8YeOPOBkd/TrtrFrT8OzGLV4hvCrICjZ78cD8wKui7TVxMsXX/ACKVn/12P83rErodXg+zeH4YMMAlywG7qRl8H8q56nXVml5IEFXNInW21S3lbG0NtJJwACMZ/DOap0VlF8rTQzrLm38vxVaTBcLKjZOerBSD+m2unrFhUXyafe/IXQFmIPAypBA/HH5VtVrjVazXVt/kduB+18v1PLK67w7oHkbby9T971jjP8Huff27fXoeHdA8jbeXqfvescZ/g9z7+3b69OlrjnPoi8Ph7e/MK5DxFr/n7rOyf910kkH8fsPb37/TqeItf8/dZ2T/ALrpJIP4/Ye3v3+nXm6cIdWTiMRf3IBRRRWpwhRRRQAUUUUAFFFFABRRRQAUUUUAdT4J/wCX3/tn/wCzV1Vcr4J/5ff+2f8A7NXVVzz+I9fDfwkebar/AMha8/67v/6Eaq1a1X/kLXn/AF3f/wBCNVa3Wx5UviYUUUUyQooooAKKKKACiiigCSCeW2nSaBykiHKsO1d/o2ppqdksvyiZeJEU/dP+B6//AKq88qzp97Lp95HcRE/KfmUHG5e4NRKN0b0KzpvyOp8TaK14gu7WMGdB86gcyD/Efr+AFcbXpdjewX9ss9u25D1B6qfQ+9ct4m0RLT/TLUYhZsPGBwhPceg/kfrxMJdGb4mimvaROsuf9Q34fzqhV+5/1Dfh/OqFOnsRjPjXoFFFFaHIFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVj+Ir3ybYW6N88vXB6L/9f/Gtg1nXmjwXlwZpZZtxAGAwwB7cV1UqUnByjuzenBuLaORorp/+Ecs/+ek//fQ/wo/4Ryz/AOek/wD30P8ACl9VqC9jM5iiun/4Ryz/AOek/wD30P8ACj/hHLP/AJ6T/wDfQ/wo+q1A9jM5iiun/wCEcs/+ek//AH0P8KP+Ecs/+ek//fQ/wo+q1A9jMj8MXO6GS3Y8ody5bseuB9f51r6RY/YY5kBG1pGdQP4Qeg/IVUsdJgsZjLE8hYrt+YjGOPb2rVibahP4V0Sg40bS3OqhB80b9DL0/SxFfzahNnfJI7RJyNoJPJ98Hp2+vSl4h1UFWs4HJbOJWB4x/d/x/L1rdnQzRMnmPGWGNyHBH0rJ/wCEas/+es//AH0P8K5eRpWRvUpzUOSmt9zlaK6r/hGrP/nrP/30P8KP+Eas/wDnrP8A99D/AAqPZyOL6pVOVorqv+Eas/8AnrP/AN9D/Cj/AIRqz/56z/8AfQ/wo9nIPqlU5Wiuq/4Rqz/56z/99D/Cj/hGrP8A56z/APfQ/wAKPZyD6pVOVorqv+Eas/8AnrP/AN9D/Cj/AIRqz/56z/8AfQ/wo9nIPqlU5Wiuq/4Rqz/56z/99D/Cj/hGrP8A56z/APfQ/wAKPZyD6pVJvD03naUiksTGShJ/MfoRTW04PrQuyo2KgPXOX6dPYY/SrOn6dFp6usMkrK5Bw5BAPtx/nFWgvzE1Fe8YJnp04XglPp+hz/ia8wEso2/25MH8h/X8q56umuPDr3M7zSXuXc5P7vp7feqL/hF/+nz/AMhf/XrCM4RVrnBWo1qk3K35HPUV0P8Awi//AE+f+Qv/AK9H/CL/APT5/wCQv/r1XtYdzL6rW7fkc9U9jcG0vYZ+cI2TgZOO/wCma2v+EX/6fP8AyF/9ej/hF/8Ap8/8hf8A16TqQfUaw1ZO6X5G+etJSRxtHBGjOXZVClz1YgdaWqg7xRnXjy1GgoooqzEKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACuZ8Uf8AIQi/64j/ANCaumqKfTLO9ZZLiHe4G0HcRxk+h961pU3UbihN2OFqS2l8i5im27vLcNjOM4Oa7H+wdM/59v8AyI3+NSRaNp0LFltUJIx8+WH5HNbrCTT3QuZFLxX/AMgyP/rsP/QWrk69De3gkiWKSGNo1+6rKCB9BUX9n2X/AD52/wD36X/Ctq2HdSXNcSdjgaK9Ajs7WJw8VtCjjoyoARU9ZrBPrIfMYvhe5EunGAkboWxgDseR+ufyrpqp1crDHR5Ywi/P9DvwP2vl+oVyPiXXWkeSwtSVRSVlfoWPdR7evr9OvXUV58XZ3O2pBzjZOx5ZRXqdFae08jk+pf3vwPLKK9Too9p5B9S/vfgeWUV6nRR7TyD6l/e/A8sor1Oij2nkH1L+9+B5ZRXqdFHtPIPqX978DyyivU6KPaeQfUv734HllFep0Ue08g+pf3vwOV8E/wDL7/2z/wDZq6qiis5O7uddKHs4qJ5tqv8AyFrz/ru//oRqrXqEsUc0ZjlRZEPVWGQfwqv/AGZYf8+Nt/36X/CtFUOSWDbd0zzeivSP7MsP+fG2/wC/S/4Uf2ZYf8+Nt/36X/Cj2iJ+py7nm9Fekf2ZYf8APjbf9+l/wo/syw/58bb/AL9L/hR7RB9Tl3PN6K9I/syw/wCfG2/79L/hR/Zlh/z423/fpf8ACj2iD6nLueb0V6R/Zlh/z423/fpf8KP7MsP+fG2/79L/AIUe0QfU5dzzeivSP7MsP+fG2/79L/hR/Zlh/wA+Nt/36X/Cj2iD6nLucVomsy6XPg5e3c/PH/Ue/wDP+Xe/u54v4ZI5F+oYH+Yqv/Zlh/z423/fpf8ACrEUUcMYjiRY0HRVGAPwqJNPU6qNOVNcrd0Nuf8AUN+H86oVfuf9Q34fzqhWlPY48Z8a9AooorQ5AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKALNlJsm2no/H49qdq17Pp9sbiK0+0IvMgD7So9ehyPX0/lUpbrVG0+WG5nJaznPlynqYpAOGHsR1AHGM9TzvTnZWFexl/8Jr/1D/8AyN/9jR/wmv8A1D//ACN/9jUHiLQFjQ6hpwDW7Dc6JyFH95f9n+X06c1SlOcXZsq51n/Ca/8AUP8A/I3/ANjR/wAJr/1D/wDyN/8AY1ydFT7WfcLnWf8ACa/9Q/8A8jf/AGNH/Ca/9Q//AMjf/Y1ydFHtZ9wudZ/wmv8A1D//ACN/9jXXx9DXklepaXK82n20sh3PJCjMcYySBmq5nKLuaUn7xh33i5rK9mtn04kxOVyZcZHY429xzVf/AITj/qHf+R//ALGsrxajL4huCykBghUkdRtAyPxB/KsasRyqTTaudd/wnH/UO/8AI/8A9jR/wnH/AFDv/I//ANjXI0UE+1n3Ou/4Tj/qHf8Akf8A+xo/4Tj/AKh3/kf/AOxrkaKA9rPudd/wnH/UO/8AI/8A9jR/wnH/AFDv/I//ANjXI0UB7Wfc67/hOP8AqHf+R/8A7Gj/AITj/qHf+R//ALGuRooD2s+513/Ccf8AUO/8j/8A2NX9I8Rz6tdeTDp21F5kkM3CD/vnr6Cue0Hw5Lqo8+VjDbA4DY5fnkD/AB9fXmu1nuLDQrBRIUhijU+XEp+Zseg7nn9cmk3Y2g5vWT0Lyrnr0rN1jWLXSBGbgSMZCQqoMnjqeeO4/Oo/Dmp3GrwXF3NsSMSeXHEo+6AM5J7k7gO3T3rmvG9wZNThhEgZYos7Rj5WJOc/gFrmqL2k1BjlP3eZGr/wmenf88br/vlf/iqP+Ez07/njdf8AfK//ABVcNRT+q0zH20juf+Ez07/njdf98r/8VR/wmenf88br/vlf/iq4aij6rTD20juf+Ez07/njdf8AfK//ABVXdL1+31WcxW1vc4UZZ2VQq/U5rgrCxn1G6W3tk3O3JJ6KPU+1dfK8dgtpoWnPi4lYee8fDBcZZsk8MQMjrgfhWVSjTXux3NITlLV7GrqMmdiA+5H+fxqjU102+4frgHHNQ11Uo8sEjKq7zYUUUVoZhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVFPqdnZMsdxNscjcBtJ4yfQe1S1zPij/kIRf8AXEf+hNWtKo6bckJq5uf29pn/AD8/+Q2/wqSLWdOmYqt0gIGfnyo/M4rhqktovPuYod23zHC5xnGTit1i5t7IXKj0HzE8rzd6+Xjduzxj1z6VB/aFl/z+W/8A39X/ABqaZY5IzFLjbKCmCcbuDkflmvPGVkYqwKspwQRgg1016zpWshJXO/jvLWVwkVzC7noquCTU9ecUVgsa+sR8p6PVyvPvD3/Iat/+Bf8AoJr0GuXF1faxi7W3/Q9DAq3N8v1CivLKK5vZ+Y/rv938T1OivLKKPZ+YfXf7v4nqdFeWUUez8w+u/wB38T1OivLKKPZ+YfXf7v4nqdFeWUUez8w+u/3fxPU6K8soo9n5h9d/u/iep0V5ZRR7PzD67/d/E9TorzCCCW5nSGBC8jnCqO9d9omlrpdn5ZYPK53SMB39B7D/AB9amUeXqbUa7qv4dDRoooqDpGSyxwxmSV1jQdWY4A/Gq/8Aadh/z/W3/f1f8a4HVf8AkLXn/Xd//QjVWtVTOCWMadkj0j+07D/n+tv+/q/40f2nYf8AP9bf9/V/xrzeij2aJ+uS7HpH9p2H/P8AW3/f1f8AGj+07D/n+tv+/q/415vRR7NB9cl2PSP7TsP+f62/7+r/AI0f2nYf8/1t/wB/V/xrzeij2aD65Lsekf2nYf8AP9bf9/V/xo/tOw/5/rb/AL+r/jXm9FHs0H1yXY9I/tOw/wCf62/7+r/jR/adh/z/AFt/39X/ABrzeij2aD65Lsekf2nYf8/1t/39X/GrEUsc0YkidZEPRlOQfxrgtE0aXVJ8nKW6H55P6D3/AJfz7393BF/DHHGv0CgfyFRJJaHVRqSqLmashtz/AKhvw/nVCr9z/qG/D+dUK0p7HHjPjXoFFFFaHIFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUrwJd281nKcJOu3P91uqn8DSUU07MDA0PWpdHuWsb7Jt1cqw6mJs84x1Geo/Ee8viLQFjQ6hpwDW7De6JyFH95f9n+X06N8WWeWi1FBxL+7l/3wOD+IHYdveovDuvtpzi2uiWtGP1MR9R7eo/Ee+ia+GWwjBorpfEWgLGh1DTgGt2G90TkKP7y/7P8AL6dOaqJRcXZjCiiipAK9G8MSvLodo0hydpXOOwJA/QCvOa7rwXK76OVY5EczKox0GAf5k1pT6ryLg7SRk+OUYarA5U7TAAGxwSGbI/UfnXN12Hj1GKWLhTtBcFscAnbgfofyrj6zHVXvsKKKKDMKKKKACiiprW1nvJhDbRPLIeyjp2yfQc9aAIkRpHVEUszHAUDJJ9K6/wAP+FVKR3WpIS+dyQHoB/tf4fn6VqaD4bg0zbO582624Ln7qeu3+Wf5ZxVDX/FiQr9n0mQNJn558ZC4PQZ4P16Y6e0t9EbqCgryNLXPENtpKPEhEt7gYj5wue7H+nXp65rgL29udQuDPdymWTAGTxgegA4FQu7SOzuxZ2OWZjkk+ppYYnnmjhiXdJIwVRnGSTgU0rGc5uTPSPDVt9k8PWqkIGkXzCVHXdyM++MD8K4LXLn7XrN3NlCDIVUp0IHAP5AV6RqEn2LTZngRB5ELMiY+UbRwMDtxXlNYU9akpGlXRJBRRRXQYBUlvby3U6QQIZJHOFUd6YiNI6oilmY4CgZJPpXX2VvB4VsTeXp33sy7ViVug4O3+WT27e+dSfKrLcuEeZ+QrvD4U0hrdZBJqFwN2VA4OMA9Pujtnqc++KHhGEzahcX0x3mBCcsxyXbPPvxu6+tYd3cyXl1LcTHLyMWPt7D2FdX4bh8jQDIQm65lJBHXaOMH8QfzqOTljZ7s0Uru62ReooorcwCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK5nxR/yEIv+uI/9CaumrmfFH/IQi/64j/0JqpbMDGrT8OwmXV4jsDLGC7Z7ccH8yKzK2tDYW1jqF6cqyRhI5MZGT29Ou2roq81cTNP7Yz2mn3K5PmXpA39QrFx+gNYWuweRq04Aba53gt3zyce2c/lVu6/5FKz/AOux/m9HiT999ivOnnw/c/u9+v8AwL9K3qvmhr5MSMSiiiuMo0vD3/Iat/8AgX/oJr0GvPvD3/Iat/8AgX/oJr0GlV+CPq/0O7Bby+X6nllFFFM4QooooAKKKKACiiigAooooAKKKKAClRWd1RFLMxwABkk0ldp4Z0b7HF9quosXL/cDdUX6dif5fjUylZGtKk6krIn8PaR/ZtsXmVftMn3iOdo/u5/z+OBVzVNQi0yzNxKC3O1FH8Tent0qW8uorK1kuJidkYycDJPYD864DVNTn1S582X5UHCRg8IP8fesopyd2d9WpGhDljudJ4WvZ7+5v57htzny8AdFHzcD2roq5XwT/wAvv/bP/wBmrqqU9y8O26ab/rU821X/AJC15/13f/0I1Vq1qv8AyFrz/ru//oRqrW62PKl8TCiiimSFFFFABRRRQAUUUUAFWdPspdQvI7eIH5j8zAZ2r3JqKCCW5nSGBC8jnCqO9d/o2mJplksXymZuZHUfeP8AgOn/AOuolKyN6FF1H5FixsoLC2WC3Xag6k9WPqfeuW8Ta2l3/odqcwq2XkB4cjsPUfzP050PE2tNZoLS1kAncfOwPMY/xP6fiDXG1MI9Wb4mskvZxPTrn/UN+H86oVfuf9Q34fzqhTp7EYz416BRRRWhyBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFACvAl3bzWcpwk67c/wB1uqn8DXBTRPBM8Ug2vGxVhnOCODXeVh+LLPLRaig4l/dy/wC+BwfxA7Dt71W6F1IvDuvtpzi2uiWtGP1MR9R7eo/Ee8/iLQFjQ6hpwDW7De6JyFH95f8AZ/l9OnNVuaB4hfTMwXAeW1OSAv3kPtnsfT8fXNRkmuWQGHRXR67okTQf2ppWJLVxuZE/h9SB6eo7fTpzlTKLi7MYV1/gaVzFdxE/IjIwGOhOc/yFchXReCXYapMgY7TCSVzwSGGD+p/Oqp/Ehrc2vG6M2ixlVJCzqWIHQYYZP4kfnXB16P4oVpPDt0FUscKcAZ4DAk/lXnFZmtb4rhRRRQYhRRXQaF4Ym1DbPdh4bVlypGNz+mPQd8n2x1zQOMXJ2Rn6Ro91qs6pEpWLPzzEfKvr9Tz0/wD113tlYWGgWEjhvLiHzSSyHLN6Zx+QA/maW7vLDw9YRh12Rj5Y4oxlm9cZ/Mk/zNcFrGs3WrXDPM5WHPyQhvlX0+p5PP8A+qpu3sb+7T9S/wCIPE8upHybMyQWoHIzhpMjnOO3t+ftz9FFNKxg227sK2PCdr9q1+3ym9IcytzjGOh/7621j113gG1zNd3ZDjaojU/wnJyfxGF/OlJ2Q4K8kafjS48rRHTbnzpFTOen8Wf/AB3H4159XUeO5997awbcbIy+7PXccY/8d/WuXrOgvcv3Kqu8goorovDGjR3O6/v1xaxcoHwFcjqT7D8vyIrSc1BXZMYuTsifQtNt9P0/+29RBIUboo9vTnAOO5J6du/0wtW1KXVL1riUBeNqKP4V9M9+tWdd1uXVp8DKWyH5I/6n3/l+ZOVUQg780typyVuWOwqI0jqiKWZjgKBkk+lehPH9nht7XfvEESpnGMkDGf5VyPhq0N3rcAwdsR81iCBjb0/XA/GutlbfIzc8nvVbz9AWkPUZRRRVmYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXM+KP8AkIRf9cR/6E1dNXM+KP8AkIRf9cR/6E1UtmBjVtOy2/hWNVI3XUpLAnnAPb/vlfzrFrb8SfufsVn18iH7/wDe7dP+A/rWlPSMpf1qJhdf8ilZ/wDXY/zenTE3PhKIh9xt5Pn3ZyOSAB+DLTbr/kUrP/rsf5vTtBzcadqFn8rlk3RxnHLYIz+YX6cVstZcveP6CMKiiiuMo0vD3/Iat/8AgX/oJr0GvPvD3/Iat/8AgX/oJr0GlV+CPq/0O7Bby+X6nllFFFM4QooooAKKKKACiiigAooooAKKK6LwzoiXf+mXQzCrYSMjhyO59R/M/TlN2Vy6cHOXKiz4X0Vdi391Gd2cwqw4x/e/w/P0rpJ54raB5p3CRoMsx7U52VEZ3YKqjJJOABXE+INdbUHNvbkraqfoZD6n29B+P0xV5s9JuOHhZblfW9Zl1SfAyluh+SP+p9/5fzzKKK2SseZKTk7s6nwT/wAvv/bP/wBmrqq5XwT/AMvv/bP/ANmrqqwn8R6uG/hI821X/kLXn/Xd/wD0I1Vq1qv/ACFrz/ru/wD6Eaq1utjypfEwooopkhRRRQAUUUUAFFFdR4X0Vt6391GNuMwqw5z/AHv8Pz9KTdlc0p03UlyoveHdESyiW6nG65dcgEf6sHt9fX8vrY13V49Mtiqtm5kU+Wo/h/2j7fz/ADq3qF7Fp9nJcSkfKPlUnG5uwFefX17Pf3LT3DbnPQDoo9B7VlFczuzuqzVCHJDcgdmd2d2LMxySTkk0lFFbHmnp1z/qG/D+dUKv3P8AqG/D+dUKzp7HXjPjXoFFFFaHIFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFK8CXdvNZynCTrtz/dbqp/A0lFNOzA4OaJ4JnikG142KsM5wRwaZXR+LLPLRaig4l/dy/74HB/EDsO3vXOUNWYkauha3LpM+DmS2c/vI/T/AGh7/wA/yxf1rQkljXUdHHnW8vJjjGce6j09R2/lzdauha3LpM+DmS2c/vI/T/aHv/P8sVGStyy2GZVa/hV2XX7cKxAYMGAPUbScH8QK1td0SLUIP7U0rEhcbmRP+WnqQP73qP69ee0d2TWLMoxU+cgyDjgkAj8qfK4yQHo2pK0mkXaIpZ2gcKoGSTtPFeW162n3a8ldGjdkdSrKcFSMEH0qZq0mbVdosSlRGkdURSzMcBQMkn0qazsri/nEFrEZJME4HGB6kngV32heHbfTESVwJLvB3S9lz2Uf169fXFQ3YiEHIzdA8KLGPP1SMNJn5Ic5C4PU44P06Y/TR17xHDpB8iFRPdEZK5wI+OCf049PTiszxB4swJbPTD/stcg/nt/+K+uOxrjqVubc0lNRXLEmu7u4vZjNdTPLIe7HpznA9Bz0FQ0UVRgFFFFABXong6FYfDsbqSTM7O2exzt4/BRXndeq4XTNIRXJdbWAZIGCwVfT8Kxru0Daitbnn3iW5+1a7dMC+1G8sBu23g49s5P41l0ru0js7sWZjksTkk+tXdI0qfVrryoflReZJCOEH+PoKtWhHXoZ6yZa8OaM2qXYeVD9kjP7xs43Hso/TPt+FT+JdZ+1SGxs2RbKLA/d9HI/oOw6cZ9MWvEuqRW0C6RpjCOJAVl2dv8AZz+ef59a5as4JzfPL5FyfIuVfMKKKK3MjqPCFvtt727ZM8CJGz68sMf981r1DpcP2XQbOMhN0gMrFe+eRn8CB+FTVENbs0npZBRRRVmYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXM+KP+QhF/wBcR/6E1dNXM+KP+QhF/wBcR/6E1UtmBR0qD7TqdvFhSC4JDdCByR+Qp2tS+dq1y23bh9uM5+7x/SrXhxFS5nvJELJbRFsg8g//AKt1ZLMzsWYlmY5JJySat6U15sXU2rr/AJFKz/67H+b1D4alaPV0UAYkVlOfTGf6VNdf8ilZ/wDXY/zesi2l8i5im27vLcNjOM4OauUuWcX5ICS/hFvf3EQQoqyEKD6Z4/Sq9a/ieJY9V3AnMkasc+vI/pWRWVSPLNoEaXh7/kNW/wDwL/0E16DXn3h7/kNW/wDwL/0E16DWdX4I+r/Q78FvL5fqeWUUUUzhCiiigAooooAKKKKACiitPRNGl1SfJyluh+eT+g9/5fzTdioxcnZFjw/oTag4uLgFbVT9DIfQe3qfw+nbIqoioihVUYAAwAKbBBFbQJDAgSNBhVHaud8S66saSWFqQzsCsr9Qo7qPf19Pr0xbc2enFQw8LsreItf8/dZ2T/uukkg/j9h7e/f6deboorZJJHm1KjqO7CiiimQdT4J/5ff+2f8A7NXVVyvgn/l9/wC2f/s1dVXPP4j18N/CR5tqv/IWvP8Aru//AKEaq1a1X/kLXn/Xd/8A0I1VrdbHlS+JhRRRTJCiiigAooq9pGmy6neLGqnylIMr9Nq/4+lDdhxi5OyLnh7RP7SkM85xbRtggHlz6ew9/wDI7WeeK2geadwkaDLMe1EEEVtAkMCBI0GFUdq47xJrTXk7WlvIPsqHkqf9Yf8AAH/H0rDWbPS93DU/Moazqb6netL8whXiNGP3R/iev/6qoUUVulY82UnJ3YUUUUCPTrn/AFDfh/OqFX7n/UN+H86oVnT2OvGfGvQKKKK0OQKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAFeBLu3ms5ThJ125/ut1U/ga4KaJ4JnikG142KsM5wRwa7ysPxZZ5aLUUHEv7uX/fA4P4gdh296rdC6nOUUUVIzV0LW5dJnwcyWzn95H6f7Q9/5/lja1rR0vY11bR2y5+ciPjf/tL6N6j+vXAg0PVJ3KJYzAgZ+ddg/NsV0nh3StY01wZDCLeQ/vIGcll/2hgEZ/Hnv7bQu1ytaCukdNH3rhH0K91PXr0JGY4hctvlcYCgkngd+MdPUdM13aAhsVKVYIxQBnx8oY4BPueazrNRkzqilOCuZtta6b4fsmbKQRn7zu3zOQP1PB4HvgVxuveJLjVt0EY8m0DZCD7zjtu/nj+eM1Y1uw8Rag/2m8syVQYWOJgwX6KCT9f8BWFcWlza7ftNvLDuzt8xCufpmslrqyJzeyVkQ0UUVZiFFFFABRRRQBo+HoGuNeskQgESh+fRfmP6Cu08X3Ag0OcbyjSFY1xnnJyR+QNYXgO18zUZ7khCsMe0Z6hmPBH4Aj8at+M3lu7mz062zJI5MhjA69lOf++v61z1dZxRvHSDZythYz6jdLb2ybnbkk9FHqfaul1S8h8P6UNKsZSbojLyLgFc8kn3I4HcDHPTL99v4S04oGE+oXABIzxxnH/ARz7n+XHu7SOzuxZmOSxOST601+9d3svxF/DXmJRUkFvNcuUghklYDJVFLHHrxW3aeEr6X5rp47ZATnJ3NjHXA4/WtZTjHdmcYSlsjAqxYWcl9eRwRqx3MAzKu7YMgFj7DNdda6BpNngy77qQYPzH5cj0A4x7HNaK3AijEVvFHDGOiqOB9O1RzyfwovkjH4mJdvvuG5yBwKgpSSTknJNJWkVZJESfM2wooopkhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFcz4o/wCQhF/1xH/oTV01cz4o/wCQhF/1xH/oTVS2YDbJ1tvDt5MHKyTSCEDGQRjP8i1ZFbGqN5GiadahlbcDM3qM8j8PmP5Vj1dXS0ey/wCCJG3df8ilZ/8AXY/zesStu6/5FKz/AOux/m9YlOtuvRAjd1hvtWh6fd7mJX92d3Vjjk5+q/rWFW7ZH7X4ZuoCVL253qGH3V68H1+9WFRW1al3QI0vD3/Iat/+Bf8AoJr0GvPvD3/Iat/+Bf8AoJr0GsKvwR9X+h34LeXy/U8sooopnCFFFFABRRRQAUUVYsbKe/uVgt13OepPRR6n2oGk27Il0vTJ9UufKi+VBy8hHCD/AB9q7+ztYrK1jt4QdkYwMnJPcn86j02xj06yS2jO7byzYwWJ6n/PbFVtb1mLS4MDD3Dj5I/6n2/n/LCTcnZHp0qcaEeaW5W8Ra2llE1rAd1y64JB/wBWD3+vp+f14mldmd2d2LMxySTkk0laxjyo4KtV1JXYUUUVRkFFFFAHU+Cf+X3/ALZ/+zV1Vcr4J/5ff+2f/s1dVXPP4j18N/CR5tqv/IWvP+u7/wDoRqrVrVf+Qtef9d3/APQjVWt1seVL4mFFFFMkKKKVFZ3VEUszHAAGSTQBLZ2st7dR28IG+Q4GTgDuT+VehabYx6dZJbRndt5ZsYLE9T/ntiquhaRHplsGZc3MijzGP8P+yPb+f5VH4i1k6ZAscGDcSg7ScHYPXH8vx9MVjJ8zsj0qNNUY889yh4o1pdjWFrId2cTMp4x/d/x/L1rlKV2Z3Z3YszHJJOSTSVrFWVjhqVHUldhRRRTMwooooA9Ouf8AUN+H86oVfuf9Q34fzqhWdPY68Z8a9AooorQ5AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKd5MV3FJaXGfKnG04OCDnIP502imnZ3BkMWneHLBUdminZSRud/MJznqo4/Spxrek2SlLaIiM/MfJjCrn8cc8VUutOguQSQUc/xLx+dYN9oVzES8LGdf8Ax7tWvtLbIfLD1NqfxfhR5UMatnqzlxj8MVn3Hiq8kLhZSqsMYRAB07E8iufIKnBBB9DSVLqSHdLZGkdaumkR2lm3JnDeaSVz1x6Vej13UbeJpIbuSQHk7zu49t2cVz9TW83lPgn5D1pKV/iLjN7M6KHxpeJGqukTt3Zk5/Qj+VacHjW1dyJrdkXHVWzz+IFcbcW+B5kfKnkgVWqZRXVDc5Rdmd8NQ8N3qSPNbQo0hO4tB8zZ6ncufzzmmPoXhu7SNYJliZyCPLn+Y57YbP8ALNcJTxNIDkO34nNTyx6XF7RPdHYzeBYjKTDfukfZXiDEfiCP5VmzeDNUjiLo1vKw6IjnJ/MAfrWRb6neW27yZ3TdjO1iufyrQh8VanFGqCdiB3YBj+ZGaOV9GH7tlWfQdVt3CPYTkkZ/drvH5rkVQdGjdkdSrqcMrDBB9DXVw+N5vMHnQRFO4AKk/jk/yrQh8X2FzEyXFu/zZUoMOGGO+cfyotLsHJF7MTwPa+TpEtyybWnkOGzncq8Dj67qs36xWN0+pyRyXV0wEVvEiZK8E4GPX5iT6cfUPiHR7SyUQsI1A4hSLbjPXA6d6xL3xjK7FLG3C5yA78k+hA//AF1zTpVJTvbQ2ThGNmyFtD1jWbo3V8VgDYxvPRfRVHTHocfzqa003RLSRczPqU6gHZEMp14PHA+hb+lQRWeo6qRJqtxKIs5ER4ycdcdB/Oti3t4raIRwRhE64Fbcj6v7jJzindL7y4tyIohFbwpCgJwFAwOfToKheR3OXYn602iqjCMdkRKcpbsKKKKogKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACuc8QxNPq9tCpAaSNVBPTJYiujrKuLfz/E1pldyxw+Y3OMYLYP54rSnHmdv63EzK8SOp1QxKgRYY1QAdMYz+HXH4VlVNdyrPeTzKCFkkZgD1wTmoaVSXNJsaNu6/5FKz/67H+b1iVt3X/IpWf/AF2P83rEq6269EJG54XIknurV1Biliy3rwcf+zGsWSNopXjkGHQlWHoRVvRZfJ1a2bbuy+3Gcfe4/rUmvwiHV5wqFVYhxnvkcn880PWkn2YdRfD3/Iat/wDgX/oJr0GvPvD3/Iat/wDgX/oJr0GsKvwR9X+h34LeXy/U8sooopnCFFFFABRRSorO6oilmY4AAySaAHwQS3M6QwIXkc4VR3rv9G0xNMsli+UzNzI6j7x/wHT/APXUPh/SF021DyoPtUg+c5zgf3R/X3/Cr19ewWFs09w21B0A6sfQe9YzlfRHp0KKprnlv+RFqmpwaXbebL8znhIweXP+HvXns88tzO807l5HOWY96l1C9l1C8kuJSfmPyqTnavYCq1XGPKcles6j8goooqznCiiigAooooA6nwT/AMvv/bP/ANmrqq5XwT/y+/8AbP8A9mrqq55/Eevhv4SPNtV/5C15/wBd3/8AQjVWrWq/8ha8/wCu7/8AoRqrW62PKl8TCiiimSFdj4Z0R7T/AEy6GJmXCRkcoD3Pof5D68UPDOiJd/6ZdDMKthIyOHI7n1H8z9OeruriO0tpLiU4SNSx9/Ye9ZTl0R34ajb95Ig1TU4NLtvNl+ZzwkYPLn/D3rz2eeW5neady8jnLMe9WdU1OfVLnzZflQcJGDwg/wAfeqVVCNkYV63tHpsFFFFWc4UUUUAFFFFAHp1z/qG/D+dUKv3P+ob8P51QrOnsdeM+NegUUUVocgUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBWu7C3u1IljGf7w4NYl94fljy9q3mL12nqP8a6SigdzgpI3iYrIjKQcYIptd1cWsFyMTRK/1rEvfDpGWs3z/sOf6/nTDToY9vceWdr8of0p1zAFHmJjaeoqKaCWBtssbIfQin28+z5H5Q/pVJ9GWndcsiCip7iDy/nTlD+lQVLViGmnZhRRT4omlbA6dz6UJXFuIiNIwVRzVr5LSPn5pGH+fwpyjY3kWymSZjjAGTWrY6B8wmvn3t18sH+Z71ppD1L+H1Mm1srnU5souEzgufur7V0en6Tb2IDD95N/z0YdPoO1XkRY0CIoVR0AGAKWs27kBRRRSAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKoXwEDXd4WdCtoI0YdMlm/XO386v1neJGkGjgJna0gD4GeOfy5xW9HRt9kJnI0UUVgM27r/kUrP/rsf5vWJW3df8ilZ/8AXY/zesStq269EJCqzIwZSVZTkEHBBrc8T7JvsV2m4edH0PYcEfj81YVb8zfbPCUbGTLWzgMNvocAfkwop6xlH5/cDKXh7/kNW/8AwL/0E16DXn3h7/kNW/8AwL/0E16DWFX4I+r/AEO/Bby+X6nllFFFM4QooooAK7bw7oiWUS3U43XLrkAj/Vg9vr6/l9a3hrQljSO/ugGdgGiTqFHZj7+np9enSOyojO7BVUZJJwAKxnLoj0MNQt78hs88VtA807hI0GWY9q8+1fUpdTvGkZj5SkiJOm1f8fWp9d1eTU7kqrYto2PlqP4v9o+/8vzrKqoRtqzHEV+d8sdgooorQ5QooooAKKKKACiiigDqfBP/AC+/9s//AGauqrlfBP8Ay+/9s/8A2auqrnn8R6+G/hI821X/AJC15/13f/0I1Vq1qv8AyFrz/ru//oRqrW62PKl8TCtXQtIk1O5DMuLaNh5jH+L/AGR7/wAvyqpptjJqN6ltGdu7lmxkKB1P+e+K9Cs7WKytY7eEHZGMDJyT3J/OpnK2h0Yej7R8z2JP3cEX8Mcca/QKB/IVw3iHV/7SuQkLN9mj+6DxuP8Aex/n8MmtDxPrbmSTT7Y7UHErg/e/2R7ev5fXmKUI9WXia1/cjsFFFFaHEFFFFABRRRQAUUUUAenXP+ob8P51Qq/c/wCob8P51QrOnsdeM+NegUUUVocgUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFADZYo5kKSoHU9iKxb7w8jZe0baeuxun4H8q3KKB3OQ8iezJiuo2VDwGI496rXFuYjuX7n8q7dlV1KuoZT2IyKzbrRopEIgIUdNjdP8A61WmmrMu6aszmIITK3oo6mtez0yacARr5MJ58w9T9B/WtWz0yKBQZAJH+nAq9Vcyivd3JvbRFe0srezTbBGAcYLH7x+pqxRRWRIUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABUiPjg9Kjoq4TdN80QauYer+H/v3NiPcwgfnt/w/wD1VzrKyMVYFWU4IIwQa9AVyv0qjqujQ6jmVD5dxjAYdG9N3+P866HTjWXNT0fYm9tzHuv+RSs/+ux/m9Ylb+pW8tr4ZtYZl2yLNyMg/wB49qwKyrKzSfZDQVv+H/8AStOvrE+XlhuQN6kYz9AQtYFa3hmXy9WVdufNRlznp3/pRQdqiv1B7Efh7/kNW/8AwL/0E16DXD6fb/ZfFQhC7VV32jOfl2kj9MV3FY11aCT7v9DvwX2vl+p5ZRRRQcIV0nh3QPP23l6n7rrHGf4/c+3t3+nWt4f0JtQcXFwCtqp+hkPoPb1P4fTtkVURURQqqMAAYAFZTn0R24ahf35bDq4rxJrTXk7WlvIPsqHkqf8AWH/AH/H0qz4n1tzJJp9sdqDiVwfvf7I9vX8vrzFEI9WPE17+5EKKKK1OEKKKKACiiigAooooAKKKKAOp8E/8vv8A2z/9mrqq5XwT/wAvv/bP/wBmrqq55/Eevhv4SPNtV/5C15/13f8A9CNQwQS3M6QwIXkc4VR3qbVf+Qtef9d3/wDQjXX+HtE/s2MzznNzIuCAeEHp7n3/AMnVy5UefCk6k2uhb0jTYtMs1jVR5rAGV+u5v8PSqHiTWls4GtLeQ/anHJU/6sf4kf4+lXdb1RdLs/MCh5XO2NSe/qfYf4etcBLI80ryyHc7sWY46k9aiEbu7OqvVVOPs4DKKKK2POCiiigAooooAKKKKACiiigD065/1Dfh/OqFX7n/AFDfh/OqFZ09jrxnxr0CiiitDkCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACnKxU8U2imm4u6AS7tINQt/KnUlc5GDgg4xn9a4/U9Kn01gZMPExwsi9PofQ12QODkU9hHOhjlRXU9VYZBrrUoV1aWkidjzyprSVYLyCZgSscisQOuAc1raxoLWqvcWpLwg5ZO6D+o/wA+9Ydc8oSpysx7nVTweX4ttpQGxKhJJ6ZCkYH4AfnXU1zsTfazpF4ZNzDcrfLjLFDn9VNdFRjEtGurb/BHfgftfL9TyytPRNGl1SfJyluh+eT+g9/5fzh0vTJ9UufKi+VBy8hHCD/H2r0C1t47S2jt4hhI1Cj39z71hOVtEZ4ehzvmlsPijSGJIoxtRFCqM9AOlYHibW3tP9DtTiZly8gPKA9h6H+Q+vFjxDrf9mxiCAZuZFyCRwg9fc+3+Tw7szuzuxZmOSSckmohG+rN8RX5VyR3EooorY84KKKKACiiigAooooAKKKKACiiigDqfBP/AC+/9s//AGauqrlfBP8Ay+/9s/8A2auqrnn8R6+G/hIwdL0Vf7Tur+6jO77Q5hVhxjd97/D8/Sta+vYLC2ae4bag6AdWPoPerFcvqunatrV4N0KW8EYPl+Y4Pp1255P5cfmL3nqEv3UbQV2c7qF7LqF5JcSk/MflUnO1ewFVq3/+ERv/APntbf8AfTf/ABNWv+EN/wCn/wD8g/8A2Va80Uef7CrJ3sctRXYQ+ELVUInuZnbPBQBRj6HNTReFNOSQMzTyAfws4wfyANHtEUsLUZxNFd9/wjmk/wDPp/5Ef/GrKaVp6Iqiyt8KMDMYJ/M9aXtEWsHPq0ecU+KKSaQRxI0jnoqjJP4V6XFDBbRlYY44UzkhFCjNO8yP++v50vaeRX1RLeR5z/Zl/wD8+Nz/AN+m/wAKsp4e1V0VhaHDDIy6g/kTxXd/aIv736Gmm6jB43H3Ao5pdhexoreRxsHhbU5d29YocdN75z/3zmpk8IXpdQ89uFzyQWJA+mK6o3a4+VST78Uhu+OE5+tF5hy4ZdSW5/1Dfh/OqFTPcO6FSFwfSoaqCaWpliKkakrxCiiirOcKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAClpKKAJEfs351kaxoKXXmXFr8lweSvRX9fof8+9adPR8cHpXXTrKa5Kv3ktdjO8Nu409reVdkkDkbCMMAeQSPxNdFVIBdxcAbiACcckf5Jq7WeOXLGC9f0O/A/a+X6lexsoLC2WC3Xag6k9WPqfeqet6zFpcGBh7hx8kf9T7fz/lqVj33h22v7lp7i4uWc9AGXCj0HHSvPVr6nbNSUbUziJ55bmd5p3LyOcsx71HXff8I5pP/Pp/5Ef/ABqaHRtNgQqllCQTn513n8zmtfaI4fqc29Wed0V6ZDZ2tu5eC2hiYjBKIFOPwqel7TyKWCfWR5t/Zl//AM+Nz/36b/Cp4dC1OdCyWbgA4+chD+RxXf8AmR/31/OkM8anBcfhzRzy7D+rUlvI4eLwzqjyBWgWMH+JpBgflk1Y/wCERv8A/ntbf99N/wDE11xuYwOCT9BTTdpjhWzRzT7B7LDreRzieDmKKXvgGxyBFkA/XNTQeD7dd32i6lf02KEx+ea2/tf+x+tNN2+eFUD3o98L4Zf0zNTwlp6urGS4YA5Klhg+3Aqz/wAI5pP/AD6f+RH/AMana5kPQgfQUhnlIwXP4Ucsu4vbUFtEdFpGnRRhFsoCB/eQMfzPNTwWtvbbvs8EUW7rsQLn8qqeZJ/fb86aTk5PWj2b6sPrUFtE0S6qcMwB9zTTNGoyXH4c1n0UezQnjJdEX/tEX979DTPtcfo35VTop+zRDxdRls3YzwhI9zTWu2/hUD681Wop8kSHiar6k5upMdFH4U37RL/e/QVFRT5V2Jdao/tMeZZCc72/OmlixyxJPvSUVVjNyb3YUUUUCCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigBysVqybtcfKpJ9+KqUUS95JPoaU6sqd+XqWjd8cJz9ab9rk9F/Kq9FTyRKeIqvqTG4lz97H4U1ppG6ufw4qOinyoh1JvdscXcjBZiPc02iimS23uFFFFAgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA//Z", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_b2604a3c2c8f4e269fd0c322dffc8e0b" + } + }, + "98d90b3d4ebd411a83abaa4cc07986e8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9b1dd5b7ae08434780df8c2e64a00d65": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9b59d44ffb7d4b238d06150e744f3b4d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [ + "widget-interact" + ], + "children": [ + "IPY_MODEL_b6b39687a287427883c31131a9b9f769", + "IPY_MODEL_972d52b3c02e41bdb136ed10f38bf44b" + ], + "layout": "IPY_MODEL_98d90b3d4ebd411a83abaa4cc07986e8" + } + }, + "9bcec2011f0c486fb924fa7172df1eb4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9de5d09d2de14559a6e1b30e78020e52": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_365398449b8a4739988051896039fa3a" + } + }, + "9fd4f2bfca9541819bcb629c760281ed": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_9b1dd5b7ae08434780df8c2e64a00d65" + } + }, + "9fda09fe038f44bda7c14162a767c606": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_4887c0e8468349cbafcbd8b3d8aa6fbd" + } + }, + "a127ce11df8942c49b6bee68d7700778": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_55164477924b4245b737ef500a432be0" + } + }, + "a288de127d224e0e82c1712ebbf8deaf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a38751ef0642440ea032d88fa3c51b40": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_ccaf6040fd3442239aaf30c2b783a12c" + } + }, + "a487eb84e8204ecb917d2b7cd9b32355": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a6e325eb84a34d7c886cc7e601eeb456": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_3e67b0173c7d4d0aa14f17cfe314c0ee" + } + }, + "a78bea59d3e24b07ba3db0ed935ee363": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a7bd29798fd8472c9efb68a3dd2987cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a9e96fb372744b529fdf439566b62018": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_25be8dd0b3c94728b96f4776197809fa" + } + }, + "b2604a3c2c8f4e269fd0c322dffc8e0b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b29d1852b22d4b8085ba983605d04c94": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b652f41ea28c4516a4d7a09fea6eecc9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b6b39687a287427883c31131a9b9f769": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatLogSliderModel", + "state": { + "behavior": "drag-tap", + "description": "wireframe_thickness", + "layout": "IPY_MODEL_f432aafe4c29403f84c45513e18304ee", + "max": -0.4, + "min": -3, + "readout_format": ".3f", + "style": "IPY_MODEL_f0a1bf2ea9ee4df4985dee3252e798de", + "value": 0.0501187233627272 + } + }, + "b8a5514c3ef6441eabe6b134805c6bdd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b97476a5b26741d69b598983a9f60d48": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_a78bea59d3e24b07ba3db0ed935ee363" + } + }, + "c152c49ec58846bd9ebe71b9fa88e1b6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "c29eb1dd56b94eac8a8d79fd36b76504": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "c69eefd6e3ba4c309cbe92b7ad430353": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_883050fc8e244613b62e9aee196b7ae4" + } + }, + "c74d79409bc0415c85ff0e0ab84b90cc": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_5e1d0da65fef47868fe59005668870da" + } + }, + "c814137f17234c62af85b056cd34e3e3": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_c152c49ec58846bd9ebe71b9fa88e1b6" + } + }, + "c83af41cbb3542708293e7f95bfed76d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "cad2738b444c452ebf92880dbd7c86f1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ccaf6040fd3442239aaf30c2b783a12c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ccdb7dd7ad424cc295bd078a8bfe6fcb": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_b652f41ea28c4516a4d7a09fea6eecc9" + } + }, + "cf3fd1be75ab4524bfa268481d0adbe5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "cfed2b9aa96e4204aa505002deb6e0fe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d19ff89eddb544b9a3265ad5d782bd1b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d39adcded3294f6397e9601ed6533fff": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_a288de127d224e0e82c1712ebbf8deaf" + } + }, + "d659201e93404677ab5964b8d47f3efc": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_9548190091d34d27a44714164b565f8b" + } + }, + "d6f9d7e00b1e4d1b822d63b5dabee6c4": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_10785ebff0264da2a584b1cbdc280d7c" + } + }, + "d724b65f47394132bca6fee2f40b6372": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_45a32f90ecdc4264ba917e6a77b5be84" + } + }, + "d7790747ebbf424ca165460ce9d6033e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d7995ce46a94421881e055f652521fac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d849a014eb9d4450b4390cc10fc7c2d2": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_687d435e027b48e984eb2789ad6f2d03" + } + }, + "db7c6da2896d474caab9f3273acd25e9": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_8f03211affc24281a3c755e1a413b5b7" + } + }, + "dbd2f3c8304f4641804ec118025a984d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "dc65a72c8e16444f9527a674358775f8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "de140a46f9804963aa30dd4770d5ea85": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_dbd2f3c8304f4641804ec118025a984d" + } + }, + "dfefc663d1aa478eb813d24a111499bf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "e046c6442bc34b1eb9dfa1629f4552c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "edd25b2880624ccfa8df8c65afe0b939": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_cf3fd1be75ab4524bfa268481d0adbe5" + } + }, + "eddd2bdec793468ba5645a5eeb859468": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ee7eb3a7bd584def8d242b9d7b76d100": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_d7790747ebbf424ca165460ce9d6033e" + } + }, + "f05d0264cb5b449b9543509c2bedc711": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_572f59892959494ca9ebeefdfd5c80af" + } + }, + "f0a1bf2ea9ee4df4985dee3252e798de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "SliderStyleModel", + "state": { + "description_width": "" + } + }, + "f0f302daf7614dff902bc48644733b95": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_f27ccad7a18f4136b1ad6cde41a06b5a" + } + }, + "f27ccad7a18f4136b1ad6cde41a06b5a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "f432aafe4c29403f84c45513e18304ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "fd74b845a9f242c5969dee72199a79bc": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_076373e179904a4ea7bb68807ef129a9" + } + }, + "fd76f2be3af54b05977e47137750f95f": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_570818bdbfe7490abbd09a27602e7dde" + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/loss.py b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/loss.py new file mode 100644 index 0000000000000000000000000000000000000000..ba507f081d5a00229abb9f683f82ede735e153c4 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/loss.py @@ -0,0 +1,95 @@ +# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited. +import torch +import torch_scatter + +############################################################################### +# Pytorch implementation of the developability regularizer introduced in paper +# "Developability of Triangle Meshes" by Stein et al. +############################################################################### +def mesh_developable_reg(mesh): + + verts = mesh.vertices + tris = mesh.faces + + device = verts.device + V = verts.shape[0] + F = tris.shape[0] + + POS_EPS = 1e-6 + REL_EPS = 1e-6 + + def normalize(vecs): + return vecs / (torch.linalg.norm(vecs, dim=-1, keepdim=True) + POS_EPS) + + tri_pos = verts[tris] + + vert_normal_covariance_sum = torch.zeros((V, 9), device=device) + vert_area = torch.zeros(V, device=device) + vert_degree = torch.zeros(V, dtype=torch.int32, device=device) + + for iC in range(3): # loop over three corners of each triangle + + # gather tri verts + pRoot = tri_pos[:, iC, :] + pA = tri_pos[:, (iC + 1) % 3, :] + pB = tri_pos[:, (iC + 2) % 3, :] + + # compute the corner angle & normal + vA = pA - pRoot + vAn = normalize(vA) + vB = pB - pRoot + vBn = normalize(vB) + area_normal = torch.linalg.cross(vA, vB, dim=-1) + face_area = 0.5 * torch.linalg.norm(area_normal, dim=-1) + normal = normalize(area_normal) + corner_angle = torch.acos(torch.clamp(torch.sum(vAn * vBn, dim=-1), min=-1., max=1.)) + + # add up the contribution to the covariance matrix + outer = normal[:, :, None] @ normal[:, None, :] + contrib = corner_angle[:, None] * outer.reshape(-1, 9) + + # scatter the result to the appropriate matrices + vert_normal_covariance_sum = torch_scatter.scatter_add(src=contrib, + index=tris[:, iC], + dim=-2, + out=vert_normal_covariance_sum) + + vert_area = torch_scatter.scatter_add(src=face_area / 3., + index=tris[:, iC], + dim=-1, + out=vert_area) + + vert_degree = torch_scatter.scatter_add(src=torch.ones(F, dtype=torch.int32, device=device), + index=tris[:, iC], + dim=-1, + out=vert_degree) + + # The energy is the smallest eigenvalue of the outer-product matrix + vert_normal_covariance_sum = vert_normal_covariance_sum.reshape( + -1, 3, 3) # reshape to a batch of matrices + vert_normal_covariance_sum = vert_normal_covariance_sum + torch.eye( + 3, device=device)[None, :, :] * REL_EPS + + min_eigvals = torch.min(torch.linalg.eigvals(vert_normal_covariance_sum).abs(), dim=-1).values + + # Mask out degree-3 vertices + vert_area = torch.where(vert_degree == 3, torch.tensor(0, dtype=vert_area.dtype,device=vert_area.device), vert_area) + + # Adjust the vertex area weighting so it is unit-less, and 1 on average + vert_area = vert_area * (V / torch.sum(vert_area, dim=-1, keepdim=True)) + + return vert_area * min_eigvals + +def sdf_reg_loss(sdf, all_edges): + sdf_f1x6x2 = sdf[all_edges.reshape(-1)].reshape(-1,2) + mask = torch.sign(sdf_f1x6x2[...,0]) != torch.sign(sdf_f1x6x2[...,1]) + sdf_f1x6x2 = sdf_f1x6x2[mask] + sdf_diff = torch.nn.functional.binary_cross_entropy_with_logits(sdf_f1x6x2[...,0], (sdf_f1x6x2[...,1] > 0).float()) + \ + torch.nn.functional.binary_cross_entropy_with_logits(sdf_f1x6x2[...,1], (sdf_f1x6x2[...,0] > 0).float()) + return sdf_diff \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/optimization.ipynb b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/optimization.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..21f153b3ad77829b19ec5884716206216734c34d --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/optimization.ipynb @@ -0,0 +1,801 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gradient-Based Mesh Optimization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "FlexiCubes is an isosurface representation designed for gradient-based mesh optimization, where we iteratively\n", + "optimize for a 3D surface mesh by representing it as the isosurface of a scalar field. Essentially, this paradigm allows objectives to be directly evaluated on the extracted surface, while offering the flexibility to optimize over meshes with different topologies.\n", + "\n", + "In this tutorial, we demonstrate how to reconstruct an unknown mesh using multiview masks and depth supervision with FlexiCubes. Note that in our paper, we demonstrate more objectives that FlexiCubes can optimize for a variety of applications." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We begin by importing the necessary packages and defining the hyperparameters for optimization." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import tqdm\n", + "import numpy as np\n", + "import kaolin as kal\n", + "from matplotlib import pyplot as plt\n", + "\n", + "import render\n", + "import loss\n", + "\n", + "iter = 1000\n", + "batch = 8\n", + "train_res = [2048, 2048]\n", + "learning_rate = 0.01\n", + "voxel_grid_res = 64\n", + "device = 'cuda'\n", + "sdf_regularizer = 0.2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we load the reference mesh and initialize a FlexiCubes object. We will be optimizing its SDF, weights, and deformations to fit the reference mesh. In this example, we are directly applying gradient descents on these parameters. Alternatively, you can parameterize them using a network of your choice and optimize the network weights instead (Please refer to the GET3D GitHub page for more details)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "gt_mesh = kal.io.obj.import_mesh('data/inputmodels/block.obj').cuda()\n", + "vertices = gt_mesh.vertices\n", + "vmin, vmax = vertices.min(dim=0)[0], vertices.max(dim=0)[0]\n", + "scale = 1.8 / torch.max(vmax - vmin).item()\n", + "vertices = vertices - (vmax + vmin) / 2 # Center mesh on origin\n", + "gt_mesh.vertices = vertices * scale # Rescale to [-0.9, 0.9]\n", + "\n", + "fc = kal.non_commercial.FlexiCubes(device)\n", + "x_nx3, cube_fx8 = fc.construct_voxel_grid(voxel_grid_res)\n", + "x_nx3 *= 2 # scale up the grid so that it's larger than the target object\n", + "sdf = torch.rand_like(x_nx3[:,0]) - 0.1 # randomly initialize SDF\n", + "sdf = torch.nn.Parameter(sdf.clone().detach(), requires_grad=True)\n", + "# set per-cube learnable weights to zeros\n", + "weight = torch.zeros((cube_fx8.shape[0], 21), dtype=torch.float, device='cuda') \n", + "weight = torch.nn.Parameter(weight.clone().detach(), requires_grad=True)\n", + "\n", + "# Retrieve all the edges of the voxel grid; these edges will be utilized to \n", + "# compute the regularization loss in subsequent steps of the process.\n", + "all_edges = cube_fx8[:, fc.cube_edges].reshape(-1, 2) \n", + "grid_edges = torch.unique(all_edges, dim=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now do random initiation for the optimization" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "deform = torch.nn.Parameter(torch.zeros_like(x_nx3), requires_grad=True)\n", + "grid_verts = x_nx3 + (2-1e-8) / (voxel_grid_res * 2) * torch.tanh(deform) # apply deformation to the grid vertices\n", + "vertices, faces, L_dev = fc(\n", + " grid_verts, sdf, cube_fx8, voxel_grid_res, beta=weight[:,:12], alpha=weight[:,12:20],\n", + " gamma_f=weight[:,20], training=False) # run isosurfacing to extract the mesh\n", + "init_mesh = kal.rep.SurfaceMesh(vertices=vertices, faces=faces)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's extract the meshes from the initial FlexiCubes grid to see what it looks like. The initial mesh topology (on the left) is very different from our reference (on the right). Don't worry, it will converge to the reference in the end! " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "camera = render.get_rotate_camera(0)\n", + "f, ax = plt.subplots(1, 2)\n", + "output = render.render_mesh(init_mesh, camera, [512, 512], return_types=['normals'])\n", + "ax[0].imshow(((output['normals'][0] + 1) / 2.).cpu().detach())\n", + "output = render.render_mesh(gt_mesh, camera, [512, 512], return_types=['normals'])\n", + "ax[1].imshow(((output['normals'][0] + 1) / 2.).cpu().detach())\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also visualize interactively with [kaolin's interactive visualizer](https://kaolin.readthedocs.io/en/latest/modules/kaolin.visualize.html), by moving around the camera and adjusting a wireframe to see the topology of the meshes." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d8848758a62646579a83b9512be4164f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Canvas(height=512, width=1024), interactive(children=(FloatLogSlider(value=0.3981071705534972, …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8045d576349a4b9485522790f58ad90d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render.SplitVisualizer(init_mesh, gt_mesh, 512, 512).show(camera)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The last thing before we start the optimization is to set up the optimizers and a differentiable renderer." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def lr_schedule(iter):\n", + " return max(0.0, 10 ** (-(iter) * 0.0002)) # Exponential falloff from [1.0, 0.1] over 5k epochs. \n", + "optimizer = torch.optim.Adam([sdf, weight, deform], lr=learning_rate)\n", + "scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda x: lr_schedule(x)) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's execute the actual optimization loop. At every iteration, we perform the following steps:\n", + "\n", + "* Sample random camera poses to render both the reference and ground truth images.\n", + "* Extract the mesh with FlexiCubes, as we did above.\n", + "* Render the meshes and evaluate the reconstruction and regularization losses (please see inline comments for more details)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████| 1000/1000 [01:21<00:00, 12.34it/s]\n" + ] + } + ], + "source": [ + "intermediate_results = [init_mesh]\n", + "for it in tqdm.tqdm(range(iter)): \n", + " optimizer.zero_grad()\n", + " # sample random camera poses\n", + " cameras = render.get_random_camera_batch(batch, iter_res=train_res, device=device)\n", + " \n", + " # render gt mesh at sampled views\n", + " target = render.render_mesh(gt_mesh, cameras, train_res)\n", + "\n", + " # extract and render FlexiCubes mesh\n", + " grid_verts = x_nx3 + (2-1e-8) / (voxel_grid_res * 2) * torch.tanh(deform)\n", + " vertices, faces, L_dev = fc(\n", + " grid_verts, sdf, cube_fx8, voxel_grid_res, beta=weight[:,:12], alpha=weight[:,12:20],\n", + " gamma_f=weight[:,20], training=True)\n", + " flexicubes_mesh = kal.rep.SurfaceMesh(vertices=vertices, faces=faces)\n", + " buffers = render.render_mesh(flexicubes_mesh, cameras, train_res)\n", + "\n", + " # evaluate reconstruction loss\n", + " mask_loss = (buffers['mask'] - target['mask']).abs().mean() # mask loss\n", + " depth_loss = (((((buffers['depth'] - (target['depth']))* target['mask'])**2).sum(-1)+1e-8)).sqrt().mean() * 10 # depth loss\n", + " # evaluate regularization losses\n", + " t_iter = it / iter\n", + " # this is the regularization loss described in Equation 2 of the nvdiffrec paper by Munkberg et al., which serves to remove internal floating elements that are not visible to the user.\n", + " sdf_weight = sdf_regularizer - (sdf_regularizer - sdf_regularizer/20)*min(1.0, 4.0 * t_iter)\n", + " reg_loss = loss.sdf_reg_loss(sdf, grid_edges).mean() * sdf_weight \n", + "\n", + " reg_loss += L_dev.mean() * 0.5 # L_dev as in Equation 8 of our paper\n", + " reg_loss += (weight[:,:20]).abs().mean() * 0.1 # regularize weights to be zeros to improve the stability of the optimization process\n", + " total_loss = mask_loss + depth_loss + reg_loss\n", + " total_loss.backward()\n", + " optimizer.step()\n", + " scheduler.step()\n", + " if (it + 1) % 20 == 0: # save intermediate results every 100 iters\n", + " with torch.no_grad():\n", + " # run the mesh extraction again with the parameter 'training=False' so that each quadrilateral face is divided into two triangles, as opposed to the four triangles during the training phase.\n", + " vertices, faces, L_dev = fc(\n", + " grid_verts, sdf, cube_fx8, voxel_grid_res, beta=weight[:,:12], alpha=weight[:,12:20], gamma_f=weight[:,20], training=False)\n", + " intermediate_results.append(kal.rep.SurfaceMesh(vertices, faces))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's now visualize how the isosurface of FlexiCubes evolves during optimization. As you can see, it converges smoothly to the reference mesh, successfully recovering all sharp features." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "camera = render.get_rotate_camera(0)\n", + "output = render.render_mesh(intermediate_results[-1], camera, [512, 512], return_types=['normals'])\n", + "plt.imshow(((output['normals'][0] + 1) / 2.).cpu().detach())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the interactive visualizer we can observe the progress over the training" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c8a0ec569bd94bc1a1d03d28c11966ea", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(Canvas(height=512, width=512), interactive(children=(FloatLogSlider(value=0.3981071705534972, d…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "25bfe4b620af4b639c6fa224959aa387", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render.TimelineVisualizer(intermediate_results, 512, 512).show(camera)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.16" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "01464b2da2504749adbd6b7274ca75bb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "085feef5177e4177bad0226481487082": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "08dc165a05b44abea377150ca236aaee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "0c9a335ed82a4ac69b95375ac2072493": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "1406a0b086c44fba885def3f125720b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "IntSliderModel", + "state": { + "behavior": "drag-tap", + "description": "idx", + "layout": "IPY_MODEL_fb7e2caa208e4d23b3b7d213a846ffa6", + "max": 50, + "style": "IPY_MODEL_9f80c79a1b74412ebecafe3fec0ba1fd", + "value": 50 + } + }, + "146c8be3e4684709bd7a0cc4c9c26d8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatLogSliderModel", + "state": { + "behavior": "drag-tap", + "description": "wireframe_thickness", + "layout": "IPY_MODEL_87b796e68c60495bb44ff34e732eb7b7", + "max": -0.4, + "min": -3, + "readout_format": ".3f", + "style": "IPY_MODEL_d01e0946a1e6414c8392a524428fd2c7", + "value": 0.3981071705534972 + } + }, + "1674125334404fbd990fcf02c764cf17": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "175e276283194ef3ad6cbff39faddcc5": { + "model_module": "ipycanvas", + "model_module_version": "^0.13", + "model_name": "CanvasModel", + "state": { + "_canvas_manager": "IPY_MODEL_e7677c2fde314a1eaa968047de653735", + "_model_module_version": "^0.13", + "_view_count": 1, + "_view_module_version": "^0.13", + "height": 512, + "layout": "IPY_MODEL_01464b2da2504749adbd6b7274ca75bb", + "width": 512 + } + }, + "1efa833afd634966815b8cc068895996": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "25bfe4b620af4b639c6fa224959aa387": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "layout": "IPY_MODEL_085feef5177e4177bad0226481487082" + } + }, + "2664be4ab5fa40488c971516942f36bf": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_9e32b3d443874996b6e59c76b1a91d85" + } + }, + "39e313aa8d364b41ac45d082fca25d28": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "layout": "IPY_MODEL_fc524bdc0f9b4b94ae6f1999e3f95554" + } + }, + "408895046d204616a9ebab6116a5e615": { + "model_module": "ipyevents", + "model_module_version": "2.0.2", + "model_name": "EventModel", + "state": { + "_supported_key_events": [ + "keydown", + "keyup" + ], + "_supported_mouse_events": [ + "click", + "auxclick", + "dblclick", + "mouseenter", + "mouseleave", + "mousedown", + "mouseup", + "mousemove", + "wheel", + "contextmenu", + "dragstart", + "drag", + "dragend", + "dragenter", + "dragover", + "dragleave", + "drop" + ], + "_supported_touch_events": [ + "touchstart", + "touchend", + "touchmove", + "touchcancel" + ], + "_view_module": "@jupyter-widgets/controls", + "prevent_default_action": true, + "source": "IPY_MODEL_175e276283194ef3ad6cbff39faddcc5", + "throttle_or_debounce": "throttle", + "wait": 41, + "watched_events": [ + "wheel", + "mousedown", + "mouseup", + "mousemove", + "mouseleave", + "mouseenter", + "contextmenu" + ], + "xy_coordinate_system": "" + } + }, + "46056691cdb14083bbbd2524092c8538": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [ + "widget-interact" + ], + "children": [ + "IPY_MODEL_146c8be3e4684709bd7a0cc4c9c26d8d", + "IPY_MODEL_39e313aa8d364b41ac45d082fca25d28" + ], + "layout": "IPY_MODEL_1674125334404fbd990fcf02c764cf17" + } + }, + "652fdbe26efa422490669fffad179fac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "692844d2e14f4206aac1e7dc1b48cb75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatLogSliderModel", + "state": { + "behavior": "drag-tap", + "description": "wireframe_thickness", + "layout": "IPY_MODEL_08dc165a05b44abea377150ca236aaee", + "max": -0.4, + "min": -3, + "readout_format": ".3f", + "style": "IPY_MODEL_be225802930544059b5aa511a33856be", + "value": 0.3981071705534972 + } + }, + "8045d576349a4b9485522790f58ad90d": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "layout": "IPY_MODEL_0c9a335ed82a4ac69b95375ac2072493" + } + }, + "87b796e68c60495bb44ff34e732eb7b7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "8c4eaa0629234d68b57a3385c47d803f": { + "model_module": "ipycanvas", + "model_module_version": "^0.13", + "model_name": "CanvasModel", + "state": { + "_canvas_manager": "IPY_MODEL_e7677c2fde314a1eaa968047de653735", + "_model_module_version": "^0.13", + "_view_count": 1, + "_view_module_version": "^0.13", + "height": 512, + "layout": "IPY_MODEL_ade19f04d8b54ac4b076762f0ed8312b", + "width": 1024 + } + }, + "9e32b3d443874996b6e59c76b1a91d85": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "9f80c79a1b74412ebecafe3fec0ba1fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "SliderStyleModel", + "state": { + "description_width": "" + } + }, + "a5ecfee9168f4742ae520973c29793b8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "ade19f04d8b54ac4b076762f0ed8312b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b50e4f7ce4b3423d9a087161008a50a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "b874d18332f847bf9297a360fc401ef3": { + "model_module": "ipyevents", + "model_module_version": "2.0.2", + "model_name": "EventModel", + "state": { + "_supported_key_events": [ + "keydown", + "keyup" + ], + "_supported_mouse_events": [ + "click", + "auxclick", + "dblclick", + "mouseenter", + "mouseleave", + "mousedown", + "mouseup", + "mousemove", + "wheel", + "contextmenu", + "dragstart", + "drag", + "dragend", + "dragenter", + "dragover", + "dragleave", + "drop" + ], + "_supported_touch_events": [ + "touchstart", + "touchend", + "touchmove", + "touchcancel" + ], + "_view_module": "@jupyter-widgets/controls", + "prevent_default_action": true, + "source": "IPY_MODEL_8c4eaa0629234d68b57a3385c47d803f", + "throttle_or_debounce": "throttle", + "wait": 41, + "watched_events": [ + "wheel", + "mousedown", + "mouseup", + "mousemove", + "mouseleave", + "mouseenter", + "contextmenu" + ], + "xy_coordinate_system": "" + } + }, + "be225802930544059b5aa511a33856be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "SliderStyleModel", + "state": { + "description_width": "" + } + }, + "c8a0ec569bd94bc1a1d03d28c11966ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_175e276283194ef3ad6cbff39faddcc5", + "IPY_MODEL_e72fa88747c64c5c8b96a4335bcf2ce4" + ], + "layout": "IPY_MODEL_1efa833afd634966815b8cc068895996" + } + }, + "c8e3c3d3f224452f806184dd700058ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "d01e0946a1e6414c8392a524428fd2c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "SliderStyleModel", + "state": { + "description_width": "" + } + }, + "d4d90b2d46b94685a64c5d3a6fa98b2e": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "value" + ] + } + ], + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ImageModel", + "state": { + "layout": "IPY_MODEL_c8e3c3d3f224452f806184dd700058ad" + } + }, + "d8848758a62646579a83b9512be4164f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_8c4eaa0629234d68b57a3385c47d803f", + "IPY_MODEL_46056691cdb14083bbbd2524092c8538" + ], + "layout": "IPY_MODEL_b50e4f7ce4b3423d9a087161008a50a3" + } + }, + "e72fa88747c64c5c8b96a4335bcf2ce4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [ + "widget-interact" + ], + "children": [ + "IPY_MODEL_692844d2e14f4206aac1e7dc1b48cb75", + "IPY_MODEL_1406a0b086c44fba885def3f125720b8", + "IPY_MODEL_f95ef5123fce4aaf8063256ec35a2316" + ], + "layout": "IPY_MODEL_a5ecfee9168f4742ae520973c29793b8" + } + }, + "e7677c2fde314a1eaa968047de653735": { + "model_module": "ipycanvas", + "model_module_version": "^0.13", + "model_name": "CanvasManagerModel", + "state": { + "_model_module_version": "^0.13", + "_view_module": null, + "_view_module_version": "" + } + }, + "f95ef5123fce4aaf8063256ec35a2316": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "layout": "IPY_MODEL_652fdbe26efa422490669fffad179fac" + } + }, + "fb7e2caa208e4d23b3b7d213a846ffa6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "fc524bdc0f9b4b94ae6f1999e3f95554": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/optimize.py b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/optimize.py new file mode 100644 index 0000000000000000000000000000000000000000..332fa2cd2de6866ab2751c6609ae7d82cb2a22b3 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/optimize.py @@ -0,0 +1,150 @@ +# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited. +import argparse +import numpy as np +import torch +import nvdiffrast.torch as dr +import trimesh +import os +from util import * +import render +import loss +import imageio + +import sys +sys.path.append('..') +from flexicubes import FlexiCubes + +############################################################################### +# Functions adapted from https://github.com/NVlabs/nvdiffrec +############################################################################### + +def lr_schedule(iter): + return max(0.0, 10**(-(iter)*0.0002)) # Exponential falloff from [1.0, 0.1] over 5k epochs. + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description='flexicubes optimization') + parser.add_argument('-o', '--out_dir', type=str, default=None) + parser.add_argument('-rm', '--ref_mesh', type=str) + + parser.add_argument('-i', '--iter', type=int, default=1000) + parser.add_argument('-b', '--batch', type=int, default=8) + parser.add_argument('-r', '--train_res', nargs=2, type=int, default=[2048, 2048]) + parser.add_argument('-lr', '--learning_rate', type=float, default=0.01) + parser.add_argument('--voxel_grid_res', type=int, default=64) + + parser.add_argument('--sdf_loss', type=bool, default=True) + parser.add_argument('--develop_reg', type=bool, default=False) + parser.add_argument('--sdf_regularizer', type=float, default=0.2) + + parser.add_argument('-dr', '--display_res', nargs=2, type=int, default=[512, 512]) + parser.add_argument('-si', '--save_interval', type=int, default=20) + FLAGS = parser.parse_args() + device = 'cuda' + + os.makedirs(FLAGS.out_dir, exist_ok=True) + glctx = dr.RasterizeGLContext() + + # Load GT mesh + gt_mesh = load_mesh(FLAGS.ref_mesh, device) + gt_mesh.auto_normals() # compute face normals for visualization + + # ============================================================================================== + # Create and initialize FlexiCubes + # ============================================================================================== + fc = FlexiCubes(device) + x_nx3, cube_fx8 = fc.construct_voxel_grid(FLAGS.voxel_grid_res) + x_nx3 *= 2 # scale up the grid so that it's larger than the target object + + sdf = torch.rand_like(x_nx3[:,0]) - 0.1 # randomly init SDF + sdf = torch.nn.Parameter(sdf.clone().detach(), requires_grad=True) + # set per-cube learnable weights to zeros + weight = torch.zeros((cube_fx8.shape[0], 21), dtype=torch.float, device='cuda') + weight = torch.nn.Parameter(weight.clone().detach(), requires_grad=True) + deform = torch.nn.Parameter(torch.zeros_like(x_nx3), requires_grad=True) + + # Retrieve all the edges of the voxel grid; these edges will be utilized to + # compute the regularization loss in subsequent steps of the process. + all_edges = cube_fx8[:, fc.cube_edges].reshape(-1, 2) + grid_edges = torch.unique(all_edges, dim=0) + + # ============================================================================================== + # Setup optimizer + # ============================================================================================== + optimizer = torch.optim.Adam([sdf, weight,deform], lr=FLAGS.learning_rate) + scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda x: lr_schedule(x)) + + # ============================================================================================== + # Train loop + # ============================================================================================== + for it in range(FLAGS.iter): + optimizer.zero_grad() + # sample random camera poses + mv, mvp = render.get_random_camera_batch(FLAGS.batch, iter_res=FLAGS.train_res, device=device, use_kaolin=False) + # render gt mesh + target = render.render_mesh_paper(gt_mesh, mv, mvp, FLAGS.train_res) + # extract and render FlexiCubes mesh + grid_verts = x_nx3 + (2-1e-8) / (FLAGS.voxel_grid_res * 2) * torch.tanh(deform) + vertices, faces, L_dev = fc(grid_verts, sdf, cube_fx8, FLAGS.voxel_grid_res, beta_fx12=weight[:,:12], alpha_fx8=weight[:,12:20], + gamma_f=weight[:,20], training=True) + flexicubes_mesh = Mesh(vertices, faces) + buffers = render.render_mesh_paper(flexicubes_mesh, mv, mvp, FLAGS.train_res) + + # evaluate reconstruction loss + mask_loss = (buffers['mask'] - target['mask']).abs().mean() + depth_loss = (((((buffers['depth'] - (target['depth']))* target['mask'])**2).sum(-1)+1e-8)).sqrt().mean() * 10 + + t_iter = it / FLAGS.iter + sdf_weight = FLAGS.sdf_regularizer - (FLAGS.sdf_regularizer - FLAGS.sdf_regularizer/20)*min(1.0, 4.0 * t_iter) + reg_loss = loss.sdf_reg_loss(sdf, grid_edges).mean() * sdf_weight # Loss to eliminate internal floaters that are not visible + reg_loss += L_dev.mean() * 0.5 + reg_loss += (weight[:,:20]).abs().mean() * 0.1 + total_loss = mask_loss + depth_loss + reg_loss + + if FLAGS.sdf_loss: # optionally add SDF loss to eliminate internal structures + with torch.no_grad(): + pts = sample_random_points(1000, gt_mesh) + gt_sdf = compute_sdf(pts, gt_mesh.vertices, gt_mesh.faces) + pred_sdf = compute_sdf(pts, flexicubes_mesh.vertices, flexicubes_mesh.faces) + total_loss += torch.nn.functional.mse_loss(pred_sdf, gt_sdf) * 2e3 + + # optionally add developability regularizer, as described in paper section 5.2 + if FLAGS.develop_reg: + reg_weight = max(0, t_iter - 0.8) * 5 + if reg_weight > 0: # only applied after shape converges + reg_loss = loss.mesh_developable_reg(flexicubes_mesh).mean() * 10 + reg_loss += (deform).abs().mean() + reg_loss += (weight[:,:20]).abs().mean() + total_loss = mask_loss + depth_loss + reg_loss + + total_loss.backward() + optimizer.step() + scheduler.step() + + if (it % FLAGS.save_interval == 0 or it == (FLAGS.iter-1)): # save normal image for visualization + with torch.no_grad(): + # extract mesh with training=False + vertices, faces, L_dev = fc(grid_verts, sdf, cube_fx8, FLAGS.voxel_grid_res, beta_fx12=weight[:,:12], alpha_fx8=weight[:,12:20], + gamma_f=weight[:,20], training=False) + flexicubes_mesh = Mesh(vertices, faces) + + flexicubes_mesh.auto_normals() # compute face normals for visualization + mv, mvp = render.get_rotate_camera(it//FLAGS.save_interval, iter_res=FLAGS.display_res, device=device,use_kaolin=False) + val_buffers = render.render_mesh_paper(flexicubes_mesh, mv.unsqueeze(0), mvp.unsqueeze(0), FLAGS.display_res, return_types=["normal"], white_bg=True) + val_image = ((val_buffers["normal"][0].detach().cpu().numpy()+1)/2*255).astype(np.uint8) + + gt_buffers = render.render_mesh_paper(gt_mesh, mv.unsqueeze(0), mvp.unsqueeze(0), FLAGS.display_res, return_types=["normal"], white_bg=True) + gt_image = ((gt_buffers["normal"][0].detach().cpu().numpy()+1)/2*255).astype(np.uint8) + imageio.imwrite(os.path.join(FLAGS.out_dir, '{:04d}.png'.format(it)), np.concatenate([val_image, gt_image], 1)) + print(f"Optimization Step [{it}/{FLAGS.iter}], Loss: {total_loss.item():.4f}") + + # ============================================================================================== + # Save ouput + # ============================================================================================== + mesh_np = trimesh.Trimesh(vertices = vertices.detach().cpu().numpy(), faces=faces.detach().cpu().numpy(), process=False) + mesh_np.export(os.path.join(FLAGS.out_dir, 'output_mesh.obj')) \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/render.py b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/render.py new file mode 100644 index 0000000000000000000000000000000000000000..034f9613f012dbfebaa4de1672497c4df37483f2 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/render.py @@ -0,0 +1,267 @@ +# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited. +import numpy as np +import copy +import math +from ipywidgets import interactive, HBox, VBox, FloatLogSlider, IntSlider + +import torch +import nvdiffrast.torch as dr +import kaolin as kal +import util + +############################################################################### +# Functions adapted from https://github.com/NVlabs/nvdiffrec +############################################################################### + +def get_random_camera_batch(batch_size, fovy = np.deg2rad(45), iter_res=[512,512], cam_near_far=[0.1, 1000.0], cam_radius=3.0, device="cuda", use_kaolin=True): + if use_kaolin: + camera_pos = torch.stack(kal.ops.coords.spherical2cartesian( + *kal.ops.random.sample_spherical_coords((batch_size,), azimuth_low=0., azimuth_high=math.pi * 2, + elevation_low=-math.pi / 2., elevation_high=math.pi / 2., device='cuda'), + cam_radius + ), dim=-1) + return kal.render.camera.Camera.from_args( + eye=camera_pos + torch.rand((batch_size, 1), device='cuda') * 0.5 - 0.25, + at=torch.zeros(batch_size, 3), + up=torch.tensor([[0., 1., 0.]]), + fov=fovy, + near=cam_near_far[0], far=cam_near_far[1], + height=iter_res[0], width=iter_res[1], + device='cuda' + ) + else: + def get_random_camera(): + proj_mtx = util.perspective(fovy, iter_res[1] / iter_res[0], cam_near_far[0], cam_near_far[1]) + mv = util.translate(0, 0, -cam_radius) @ util.random_rotation_translation(0.25) + mvp = proj_mtx @ mv + return mv, mvp + mv_batch = [] + mvp_batch = [] + for i in range(batch_size): + mv, mvp = get_random_camera() + mv_batch.append(mv) + mvp_batch.append(mvp) + return torch.stack(mv_batch).to(device), torch.stack(mvp_batch).to(device) + +def get_rotate_camera(itr, fovy = np.deg2rad(45), iter_res=[512,512], cam_near_far=[0.1, 1000.0], cam_radius=3.0, device="cuda", use_kaolin=True): + if use_kaolin: + ang = (itr / 10) * np.pi * 2 + camera_pos = torch.stack(kal.ops.coords.spherical2cartesian(torch.tensor(ang), torch.tensor(0.4), -torch.tensor(cam_radius))) + return kal.render.camera.Camera.from_args( + eye=camera_pos, + at=torch.zeros(3), + up=torch.tensor([0., 1., 0.]), + fov=fovy, + near=cam_near_far[0], far=cam_near_far[1], + height=iter_res[0], width=iter_res[1], + device='cuda' + ) + else: + proj_mtx = util.perspective(fovy, iter_res[1] / iter_res[0], cam_near_far[0], cam_near_far[1]) + + # Smooth rotation for display. + ang = (itr / 10) * np.pi * 2 + mv = util.translate(0, 0, -cam_radius) @ (util.rotate_x(-0.4) @ util.rotate_y(ang)) + mvp = proj_mtx @ mv + return mv.to(device), mvp.to(device) + +glctx = dr.RasterizeGLContext() +def render_mesh(mesh, camera, iter_res, return_types = ["mask", "depth"], white_bg=False, wireframe_thickness=0.4): + vertices_camera = camera.extrinsics.transform(mesh.vertices) + face_vertices_camera = kal.ops.mesh.index_vertices_by_faces( + vertices_camera, mesh.faces + ) + + # Projection: nvdiffrast take clip coordinates as input to apply barycentric perspective correction. + # Using `camera.intrinsics.transform(vertices_camera) would return the normalized device coordinates. + proj = camera.projection_matrix().unsqueeze(1) + proj[:, :, 1, 1] = -proj[:, :, 1, 1] + homogeneous_vecs = kal.render.camera.up_to_homogeneous( + vertices_camera + ) + vertices_clip = (proj @ homogeneous_vecs.unsqueeze(-1)).squeeze(-1) + faces_int = mesh.faces.int() + + rast, _ = dr.rasterize( + glctx, vertices_clip, faces_int, iter_res) + + out_dict = {} + for type in return_types: + if type == "mask" : + img = dr.antialias((rast[..., -1:] > 0).float(), rast, vertices_clip, faces_int) + elif type == "depth": + img = dr.interpolate(homogeneous_vecs, rast, faces_int)[0] + elif type == "wireframe": + img = torch.logical_or( + torch.logical_or(rast[..., 0] < wireframe_thickness, rast[..., 1] < wireframe_thickness), + (rast[..., 0] + rast[..., 1]) > (1. - wireframe_thickness) + ).unsqueeze(-1) + elif type == "normals" : + img = dr.interpolate( + mesh.face_normals.reshape(len(mesh), -1, 3), rast, + torch.arange(mesh.faces.shape[0] * 3, device='cuda', dtype=torch.int).reshape(-1, 3) + )[0] + if white_bg: + bg = torch.ones_like(img) + alpha = (rast[..., -1:] > 0).float() + img = torch.lerp(bg, img, alpha) + out_dict[type] = img + + + return out_dict + +def render_mesh_paper(mesh, mv, mvp, iter_res, return_types = ["mask", "depth"], white_bg=False): + ''' + The rendering function used to produce the results in the paper. + ''' + v_pos_clip = util.xfm_points(mesh.vertices.unsqueeze(0), mvp) # Rotate it to camera coordinates + rast, db = dr.rasterize( + dr.RasterizeGLContext(), v_pos_clip, mesh.faces.int(), iter_res) + + out_dict = {} + for type in return_types: + if type == "mask" : + img = dr.antialias((rast[..., -1:] > 0).float(), rast, v_pos_clip, mesh.faces.int()) + elif type == "depth": + v_pos_cam = util.xfm_points(mesh.vertices.unsqueeze(0), mv) + img, _ = util.interpolate(v_pos_cam, rast, mesh.faces.int()) + elif type == "normal" : + normal_indices = (torch.arange(0, mesh.nrm.shape[0], dtype=torch.int64, device='cuda')[:, None]).repeat(1, 3) + img, _ = util.interpolate(mesh.nrm.unsqueeze(0).contiguous(), rast, normal_indices.int()) + elif type == "vertex_normal": + img, _ = util.interpolate(mesh.v_nrm.unsqueeze(0).contiguous(), rast, mesh.faces.int()) + img = dr.antialias((img + 1) * 0.5, rast, v_pos_clip, mesh.faces.int()) + if white_bg: + bg = torch.ones_like(img) + alpha = (rast[..., -1:] > 0).float() + img = torch.lerp(bg, img, alpha) + out_dict[type] = img + return out_dict + +class SplitVisualizer(): + def __init__(self, lh_mesh, rh_mesh, height, width): + self.lh_mesh = lh_mesh + self.rh_mesh = rh_mesh + self.height = height + self.width = width + self.wireframe_thickness = 0.4 + + + def render(self, camera): + lh_outputs = render_mesh( + self.lh_mesh, camera, (self.height, self.width), + return_types=["normals", "wireframe"], wireframe_thickness=self.wireframe_thickness + ) + rh_outputs = render_mesh( + self.rh_mesh, camera, (self.height, self.width), + return_types=["normals", "wireframe"], wireframe_thickness=self.wireframe_thickness + ) + outputs = { + k: torch.cat( + [lh_outputs[k][0].permute(1, 0, 2), rh_outputs[k][0].permute(1, 0, 2)], + dim=0 + ).permute(1, 0, 2) for k in ["normals", "wireframe"] + } + return { + 'img': (outputs['wireframe'] * ((outputs['normals'] + 1.) / 2.) * 255).to(torch.uint8), + 'normals': outputs['normals'] + } + + def show(self, init_camera): + visualizer = kal.visualize.IpyTurntableVisualizer( + self.height, self.width * 2, copy.deepcopy(init_camera), self.render, + max_fps=24, world_up_axis=1) + + def slider_callback(new_wireframe_thickness): + """ipywidgets sliders callback""" + with visualizer.out: # This is in case of bug + self.wireframe_thickness = new_wireframe_thickness + # this is how we request a new update + visualizer.render_update() + + wireframe_thickness_slider = FloatLogSlider( + value=self.wireframe_thickness, + base=10, + min=-3, + max=-0.4, + step=0.1, + description='wireframe_thickness', + continuous_update=True, + readout=True, + readout_format='.3f', + ) + + interactive_slider = interactive( + slider_callback, + new_wireframe_thickness=wireframe_thickness_slider, + ) + + full_output = VBox([visualizer.canvas, interactive_slider]) + display(full_output, visualizer.out) + +class TimelineVisualizer(): + def __init__(self, meshes, height, width): + self.meshes = meshes + self.height = height + self.width = width + self.wireframe_thickness = 0.4 + self.idx = len(meshes) - 1 + + def render(self, camera): + outputs = render_mesh( + self.meshes[self.idx], camera, (self.height, self.width), + return_types=["normals", "wireframe"], wireframe_thickness=self.wireframe_thickness + ) + + return { + 'img': (outputs['wireframe'] * ((outputs['normals'] + 1.) / 2.) * 255).to(torch.uint8)[0], + 'normals': outputs['normals'][0] + } + + def show(self, init_camera): + visualizer = kal.visualize.IpyTurntableVisualizer( + self.height, self.width, copy.deepcopy(init_camera), self.render, + max_fps=24, world_up_axis=1) + + def slider_callback(new_wireframe_thickness, new_idx): + """ipywidgets sliders callback""" + with visualizer.out: # This is in case of bug + self.wireframe_thickness = new_wireframe_thickness + self.idx = new_idx + # this is how we request a new update + visualizer.render_update() + + wireframe_thickness_slider = FloatLogSlider( + value=self.wireframe_thickness, + base=10, + min=-3, + max=-0.4, + step=0.1, + description='wireframe_thickness', + continuous_update=True, + readout=True, + readout_format='.3f', + ) + + idx_slider = IntSlider( + value=self.idx, + min=0, + max=len(self.meshes) - 1, + description='idx', + continuous_update=True, + readout=True + ) + + interactive_slider = interactive( + slider_callback, + new_wireframe_thickness=wireframe_thickness_slider, + new_idx=idx_slider + ) + full_output = HBox([visualizer.canvas, interactive_slider]) + display(full_output, visualizer.out) diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/util.py b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/util.py new file mode 100644 index 0000000000000000000000000000000000000000..f39ea1c7570ba74e9f5315209e57a8dcc1839af0 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/examples/util.py @@ -0,0 +1,122 @@ +# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited. +import numpy as np +import torch +import trimesh +import kaolin +import nvdiffrast.torch as dr + +############################################################################### +# Functions adapted from https://github.com/NVlabs/nvdiffrec +############################################################################### + +def dot(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + return torch.sum(x*y, -1, keepdim=True) + +def length(x: torch.Tensor, eps: float =1e-8) -> torch.Tensor: + return torch.sqrt(torch.clamp(dot(x,x), min=eps)) # Clamp to avoid nan gradients because grad(sqrt(0)) = NaN + +def safe_normalize(x: torch.Tensor, eps: float =1e-8) -> torch.Tensor: + return x / length(x, eps) + +def perspective(fovy=0.7854, aspect=1.0, n=0.1, f=1000.0, device=None): + y = np.tan(fovy / 2) + return torch.tensor([[1/(y*aspect), 0, 0, 0], + [ 0, 1/-y, 0, 0], + [ 0, 0, -(f+n)/(f-n), -(2*f*n)/(f-n)], + [ 0, 0, -1, 0]], dtype=torch.float32, device=device) + +def translate(x, y, z, device=None): + return torch.tensor([[1, 0, 0, x], + [0, 1, 0, y], + [0, 0, 1, z], + [0, 0, 0, 1]], dtype=torch.float32, device=device) + +@torch.no_grad() +def random_rotation_translation(t, device=None): + m = np.random.normal(size=[3, 3]) + m[1] = np.cross(m[0], m[2]) + m[2] = np.cross(m[0], m[1]) + m = m / np.linalg.norm(m, axis=1, keepdims=True) + m = np.pad(m, [[0, 1], [0, 1]], mode='constant') + m[3, 3] = 1.0 + m[:3, 3] = np.random.uniform(-t, t, size=[3]) + return torch.tensor(m, dtype=torch.float32, device=device) + +def rotate_x(a, device=None): + s, c = np.sin(a), np.cos(a) + return torch.tensor([[1, 0, 0, 0], + [0, c, s, 0], + [0, -s, c, 0], + [0, 0, 0, 1]], dtype=torch.float32, device=device) + +def rotate_y(a, device=None): + s, c = np.sin(a), np.cos(a) + return torch.tensor([[ c, 0, s, 0], + [ 0, 1, 0, 0], + [-s, 0, c, 0], + [ 0, 0, 0, 1]], dtype=torch.float32, device=device) + +class Mesh: + def __init__(self, vertices, faces): + self.vertices = vertices + self.faces = faces + + def auto_normals(self): + v0 = self.vertices[self.faces[:, 0], :] + v1 = self.vertices[self.faces[:, 1], :] + v2 = self.vertices[self.faces[:, 2], :] + nrm = safe_normalize(torch.cross(v1 - v0, v2 - v0)) + self.nrm = nrm + +def load_mesh(path, device): + mesh_np = trimesh.load(path) + vertices = torch.tensor(mesh_np.vertices, device=device, dtype=torch.float) + faces = torch.tensor(mesh_np.faces, device=device, dtype=torch.long) + + # Normalize + vmin, vmax = vertices.min(dim=0)[0], vertices.max(dim=0)[0] + scale = 1.8 / torch.max(vmax - vmin).item() + vertices = vertices - (vmax + vmin) / 2 # Center mesh on origin + vertices = vertices * scale # Rescale to [-0.9, 0.9] + return Mesh(vertices, faces) + +def compute_sdf(points, vertices, faces): + face_vertices = kaolin.ops.mesh.index_vertices_by_faces(vertices.clone().unsqueeze(0), faces) + distance = kaolin.metrics.trianglemesh.point_to_mesh_distance(points.unsqueeze(0), face_vertices)[0] + with torch.no_grad(): + sign = (kaolin.ops.mesh.check_sign(vertices.unsqueeze(0), faces, points.unsqueeze(0))<1).float() * 2 - 1 + sdf = (sign*distance).squeeze(0) + return sdf + +def sample_random_points(n, mesh): + pts_random = (torch.rand((n//2,3),device='cuda') - 0.5) * 2 + pts_surface = kaolin.ops.mesh.sample_points(mesh.vertices.unsqueeze(0), mesh.faces, 500)[0].squeeze(0) + pts_surface += torch.randn_like(pts_surface) * 0.05 + pts = torch.cat([pts_random, pts_surface]) + return pts + +def xfm_points(points, matrix): + '''Transform points. + Args: + points: Tensor containing 3D points with shape [minibatch_size, num_vertices, 3] or [1, num_vertices, 3] + matrix: A 4x4 transform matrix with shape [minibatch_size, 4, 4] + use_python: Use PyTorch's torch.matmul (for validation) + Returns: + Transformed points in homogeneous 4D with shape [minibatch_size, num_vertices, 4]. + ''' + out = torch.matmul( + torch.nn.functional.pad(points, pad=(0, 1), mode='constant', value=1.0), torch.transpose(matrix, 1, 2)) + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of xfm_points contains inf or NaN" + return out + +def interpolate(attr, rast, attr_idx, rast_db=None): + return dr.interpolate( + attr, rast, attr_idx, rast_db=rast_db, + diff_attrs=None if rast_db is None else 'all') \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/flexicubes.py b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/flexicubes.py new file mode 100644 index 0000000000000000000000000000000000000000..15a5960be0aa2a03454ee0dec235961de0cd4564 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/flexicubes.py @@ -0,0 +1,384 @@ +# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited. + +import torch +from .tables import * +from kaolin.utils.testing import check_tensor + +__all__ = [ + 'FlexiCubes' +] + + +class FlexiCubes: + def __init__(self, device="cuda"): + + self.device = device + self.dmc_table = torch.tensor(dmc_table, dtype=torch.long, device=device, requires_grad=False) + self.num_vd_table = torch.tensor(num_vd_table, + dtype=torch.long, device=device, requires_grad=False) + self.check_table = torch.tensor( + check_table, + dtype=torch.long, device=device, requires_grad=False) + + self.tet_table = torch.tensor(tet_table, dtype=torch.long, device=device, requires_grad=False) + self.quad_split_1 = torch.tensor([0, 1, 2, 0, 2, 3], dtype=torch.long, device=device, requires_grad=False) + self.quad_split_2 = torch.tensor([0, 1, 3, 3, 1, 2], dtype=torch.long, device=device, requires_grad=False) + self.quad_split_train = torch.tensor( + [0, 1, 1, 2, 2, 3, 3, 0], dtype=torch.long, device=device, requires_grad=False) + + self.cube_corners = torch.tensor([[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [ + 1, 0, 1], [0, 1, 1], [1, 1, 1]], dtype=torch.float, device=device) + self.cube_corners_idx = torch.pow(2, torch.arange(8, requires_grad=False)) + self.cube_edges = torch.tensor([0, 1, 1, 5, 4, 5, 0, 4, 2, 3, 3, 7, 6, 7, 2, 6, + 2, 0, 3, 1, 7, 5, 6, 4], dtype=torch.long, device=device, requires_grad=False) + + self.edge_dir_table = torch.tensor([0, 2, 0, 2, 0, 2, 0, 2, 1, 1, 1, 1], + dtype=torch.long, device=device) + self.dir_faces_table = torch.tensor([ + [[5, 4], [3, 2], [4, 5], [2, 3]], + [[5, 4], [1, 0], [4, 5], [0, 1]], + [[3, 2], [1, 0], [2, 3], [0, 1]] + ], dtype=torch.long, device=device) + self.adj_pairs = torch.tensor([0, 1, 1, 3, 3, 2, 2, 0], dtype=torch.long, device=device) + + def __call__(self, voxelgrid_vertices, scalar_field, cube_idx, resolution, qef_reg_scale=1e-3, + weight_scale=0.99, beta=None, alpha=None, gamma_f=None, voxelgrid_colors=None, training=False): + assert torch.is_tensor(voxelgrid_vertices) and \ + check_tensor(voxelgrid_vertices, (None, 3), throw=False), \ + "'voxelgrid_vertices' should be a tensor of shape (num_vertices, 3)" + num_vertices = voxelgrid_vertices.shape[0] + assert torch.is_tensor(scalar_field) and \ + check_tensor(scalar_field, (num_vertices,), throw=False), \ + "'scalar_field' should be a tensor of shape (num_vertices,)" + assert torch.is_tensor(cube_idx) and \ + check_tensor(cube_idx, (None, 8), throw=False), \ + "'cube_idx' should be a tensor of shape (num_cubes, 8)" + num_cubes = cube_idx.shape[0] + assert beta is None or ( + torch.is_tensor(beta) and + check_tensor(beta, (num_cubes, 12), throw=False) + ), "'beta' should be a tensor of shape (num_cubes, 12)" + assert alpha is None or ( + torch.is_tensor(alpha) and + check_tensor(alpha, (num_cubes, 8), throw=False) + ), "'alpha' should be a tensor of shape (num_cubes, 8)" + assert gamma_f is None or ( + torch.is_tensor(gamma_f) and + check_tensor(gamma_f, (num_cubes,), throw=False) + ), "'gamma_f' should be a tensor of shape (num_cubes,)" + + surf_cubes, occ_fx8 = self._identify_surf_cubes(scalar_field, cube_idx) + if surf_cubes.sum() == 0: + return ( + torch.zeros((0, 3), device=self.device), + torch.zeros((0, 3), dtype=torch.long, device=self.device), + torch.zeros((0), device=self.device), + torch.zeros((0, voxelgrid_colors.shape[-1]), device=self.device) if voxelgrid_colors is not None else None + ) + beta, alpha, gamma_f = self._normalize_weights( + beta, alpha, gamma_f, surf_cubes, weight_scale) + + if voxelgrid_colors is not None: + voxelgrid_colors = torch.sigmoid(voxelgrid_colors) + + case_ids = self._get_case_id(occ_fx8, surf_cubes, resolution) + + surf_edges, idx_map, edge_counts, surf_edges_mask = self._identify_surf_edges( + scalar_field, cube_idx, surf_cubes + ) + + vd, L_dev, vd_gamma, vd_idx_map, vd_color = self._compute_vd( + voxelgrid_vertices, cube_idx[surf_cubes], surf_edges, scalar_field, + case_ids, beta, alpha, gamma_f, idx_map, qef_reg_scale, voxelgrid_colors) + vertices, faces, s_edges, edge_indices, vertices_color = self._triangulate( + scalar_field, surf_edges, vd, vd_gamma, edge_counts, idx_map, + vd_idx_map, surf_edges_mask, training, vd_color) + return vertices, faces, L_dev, vertices_color + + def _compute_reg_loss(self, vd, ue, edge_group_to_vd, vd_num_edges): + """ + Regularizer L_dev as in Equation 8 + """ + dist = torch.norm(ue - torch.index_select(input=vd, index=edge_group_to_vd, dim=0), dim=-1) + mean_l2 = torch.zeros_like(vd[:, 0]) + mean_l2 = (mean_l2).index_add_(0, edge_group_to_vd, dist) / vd_num_edges.squeeze(1).float() + mad = (dist - torch.index_select(input=mean_l2, index=edge_group_to_vd, dim=0)).abs() + return mad + + def _normalize_weights(self, beta, alpha, gamma_f, surf_cubes, weight_scale): + """ + Normalizes the given weights to be non-negative. If input weights are None, it creates and returns a set of weights of ones. + """ + n_cubes = surf_cubes.shape[0] + + if beta is not None: + beta = (torch.tanh(beta) * weight_scale + 1) + else: + beta = torch.ones((n_cubes, 12), dtype=torch.float, device=self.device) + + if alpha is not None: + alpha = (torch.tanh(alpha) * weight_scale + 1) + else: + alpha = torch.ones((n_cubes, 8), dtype=torch.float, device=self.device) + + if gamma_f is not None: + gamma_f = torch.sigmoid(gamma_f) * weight_scale + (1 - weight_scale) / 2 + else: + gamma_f = torch.ones((n_cubes), dtype=torch.float, device=self.device) + + return beta[surf_cubes], alpha[surf_cubes], gamma_f[surf_cubes] + + @torch.no_grad() + def _get_case_id(self, occ_fx8, surf_cubes, res): + """ + Obtains the ID of topology cases based on cell corner occupancy. This function resolves the + ambiguity in the Dual Marching Cubes (DMC) configurations as described in Section 1.3 of the + supplementary material. It should be noted that this function assumes a regular grid. + """ + case_ids = (occ_fx8[surf_cubes] * self.cube_corners_idx.to(self.device).unsqueeze(0)).sum(-1) + + problem_config = self.check_table.to(self.device)[case_ids] + to_check = problem_config[..., 0] == 1 + problem_config = problem_config[to_check] + if not isinstance(res, (list, tuple)): + res = [res, res, res] + + # The 'problematic_configs' only contain configurations for surface cubes. Next, we construct a 3D array, + # 'problem_config_full', to store configurations for all cubes (with default config for non-surface cubes). + # This allows efficient checking on adjacent cubes. + problem_config_full = torch.zeros(list(res) + [5], device=self.device, dtype=torch.long) + vol_idx = torch.nonzero(problem_config_full[..., 0] == 0) # N, 3 + vol_idx_problem = vol_idx[surf_cubes][to_check] + problem_config_full[vol_idx_problem[..., 0], vol_idx_problem[..., 1], vol_idx_problem[..., 2]] = problem_config + vol_idx_problem_adj = vol_idx_problem + problem_config[..., 1:4] + + within_range = ( + vol_idx_problem_adj[..., 0] >= 0) & ( + vol_idx_problem_adj[..., 0] < res[0]) & ( + vol_idx_problem_adj[..., 1] >= 0) & ( + vol_idx_problem_adj[..., 1] < res[1]) & ( + vol_idx_problem_adj[..., 2] >= 0) & ( + vol_idx_problem_adj[..., 2] < res[2]) + + vol_idx_problem = vol_idx_problem[within_range] + vol_idx_problem_adj = vol_idx_problem_adj[within_range] + problem_config = problem_config[within_range] + problem_config_adj = problem_config_full[vol_idx_problem_adj[..., 0], + vol_idx_problem_adj[..., 1], vol_idx_problem_adj[..., 2]] + # If two cubes with cases C16 and C19 share an ambiguous face, both cases are inverted. + to_invert = (problem_config_adj[..., 0] == 1) + idx = torch.arange(case_ids.shape[0], device=self.device)[to_check][within_range][to_invert] + case_ids.index_put_((idx,), problem_config[to_invert][..., -1]) + return case_ids + + @torch.no_grad() + def _identify_surf_edges(self, scalar_field, cube_idx, surf_cubes): + """ + Identifies grid edges that intersect with the underlying surface by checking for opposite signs. As each edge + can be shared by multiple cubes, this function also assigns a unique index to each surface-intersecting edge + and marks the cube edges with this index. + """ + occ_n = scalar_field < 0 + all_edges = cube_idx[surf_cubes][:, self.cube_edges].reshape(-1, 2) + unique_edges, _idx_map, counts = torch.unique(all_edges, dim=0, return_inverse=True, return_counts=True) + + unique_edges = unique_edges.long() + mask_edges = occ_n[unique_edges.reshape(-1)].reshape(-1, 2).sum(-1) == 1 + + surf_edges_mask = mask_edges[_idx_map] + counts = counts[_idx_map] + + mapping = torch.ones((unique_edges.shape[0]), dtype=torch.long, device=cube_idx.device) * -1 + mapping[mask_edges] = torch.arange(mask_edges.sum(), device=cube_idx.device) + # Shaped as [number of cubes x 12 edges per cube]. This is later used to map a cube edge to the unique index + # for a surface-intersecting edge. Non-surface-intersecting edges are marked with -1. + idx_map = mapping[_idx_map] + surf_edges = unique_edges[mask_edges] + return surf_edges, idx_map, counts, surf_edges_mask + + @torch.no_grad() + def _identify_surf_cubes(self, scalar_field, cube_idx): + """ + Identifies grid cubes that intersect with the underlying surface by checking if the signs at + all corners are not identical. + """ + occ_n = scalar_field < 0 + occ_fx8 = occ_n[cube_idx.reshape(-1)].reshape(-1, 8) + _occ_sum = torch.sum(occ_fx8, -1) + surf_cubes = (_occ_sum > 0) & (_occ_sum < 8) + return surf_cubes, occ_fx8 + + def _linear_interp(self, edges_weight, edges_x): + """ + Computes the location of zero-crossings on 'edges_x' using linear interpolation with 'edges_weight'. + """ + edge_dim = edges_weight.dim() - 2 + assert edges_weight.shape[edge_dim] == 2 + edges_weight = torch.cat([torch.index_select(input=edges_weight, index=torch.tensor(1, device=self.device), dim=edge_dim), - + torch.index_select(input=edges_weight, index=torch.tensor(0, device=self.device), dim=edge_dim)] + , edge_dim) + denominator = edges_weight.sum(edge_dim) + ue = (edges_x * edges_weight).sum(edge_dim) / denominator + return ue + + def _solve_vd_QEF(self, p_bxnx3, norm_bxnx3, c_bx3, qef_reg_scale): + p_bxnx3 = p_bxnx3.reshape(-1, 7, 3) + norm_bxnx3 = norm_bxnx3.reshape(-1, 7, 3) + c_bx3 = c_bx3.reshape(-1, 3) + A = norm_bxnx3 + B = ((p_bxnx3) * norm_bxnx3).sum(-1, keepdims=True) + + A_reg = (torch.eye(3, device=p_bxnx3.device) * qef_reg_scale).unsqueeze(0).repeat(p_bxnx3.shape[0], 1, 1) + B_reg = (qef_reg_scale * c_bx3).unsqueeze(-1) + A = torch.cat([A, A_reg], 1) + B = torch.cat([B, B_reg], 1) + dual_verts = torch.linalg.lstsq(A, B).solution.squeeze(-1) + return dual_verts + + def _compute_vd(self, voxelgrid_vertices, surf_cubes_fx8, surf_edges, scalar_field, + case_ids, beta, alpha, gamma_f, idx_map, qef_reg_scale, voxelgrid_colors): + """ + Computes the location of dual vertices as described in Section 4.2 + """ + alpha_nx12x2 = torch.index_select(input=alpha, index=self.cube_edges, dim=1).reshape(-1, 12, 2) + surf_edges_x = torch.index_select(input=voxelgrid_vertices, index=surf_edges.reshape(-1), dim=0).reshape(-1, 2, 3) + surf_edges_s = torch.index_select(input=scalar_field, index=surf_edges.reshape(-1), dim=0).reshape(-1, 2, 1) + zero_crossing = self._linear_interp(surf_edges_s, surf_edges_x) + + if voxelgrid_colors is not None: + C = voxelgrid_colors.shape[-1] + surf_edges_c = torch.index_select(input=voxelgrid_colors, index=surf_edges.reshape(-1), dim=0).reshape(-1, 2, C) + + idx_map = idx_map.reshape(-1, 12) + num_vd = torch.index_select(input=self.num_vd_table, index=case_ids, dim=0) + edge_group, edge_group_to_vd, edge_group_to_cube, vd_num_edges, vd_gamma = [], [], [], [], [] + + # if color is not None: + # vd_color = [] + + total_num_vd = 0 + vd_idx_map = torch.zeros((case_ids.shape[0], 12), dtype=torch.long, device=self.device, requires_grad=False) + + for num in torch.unique(num_vd): + cur_cubes = (num_vd == num) # consider cubes with the same numbers of vd emitted (for batching) + curr_num_vd = cur_cubes.sum() * num + curr_edge_group = self.dmc_table[case_ids[cur_cubes], :num].reshape(-1, num * 7) + curr_edge_group_to_vd = torch.arange( + curr_num_vd, device=self.device).unsqueeze(-1).repeat(1, 7) + total_num_vd + total_num_vd += curr_num_vd + curr_edge_group_to_cube = torch.arange(idx_map.shape[0], device=self.device)[ + cur_cubes].unsqueeze(-1).repeat(1, num * 7).reshape_as(curr_edge_group) + + curr_mask = (curr_edge_group != -1) + edge_group.append(torch.masked_select(curr_edge_group, curr_mask)) + edge_group_to_vd.append(torch.masked_select(curr_edge_group_to_vd.reshape_as(curr_edge_group), curr_mask)) + edge_group_to_cube.append(torch.masked_select(curr_edge_group_to_cube, curr_mask)) + vd_num_edges.append(curr_mask.reshape(-1, 7).sum(-1, keepdims=True)) + vd_gamma.append(torch.masked_select(gamma_f, cur_cubes).unsqueeze(-1).repeat(1, num).reshape(-1)) + # if color is not None: + # vd_color.append(color[cur_cubes].unsqueeze(1).repeat(1, num, 1).reshape(-1, 3)) + + edge_group = torch.cat(edge_group) + edge_group_to_vd = torch.cat(edge_group_to_vd) + edge_group_to_cube = torch.cat(edge_group_to_cube) + vd_num_edges = torch.cat(vd_num_edges) + vd_gamma = torch.cat(vd_gamma) + # if color is not None: + # vd_color = torch.cat(vd_color) + # else: + # vd_color = None + + vd = torch.zeros((total_num_vd, 3), device=self.device) + beta_sum = torch.zeros((total_num_vd, 1), device=self.device) + + idx_group = torch.gather(input=idx_map.reshape(-1), dim=0, index=edge_group_to_cube * 12 + edge_group) + + x_group = torch.index_select(input=surf_edges_x, index=idx_group.reshape(-1), dim=0).reshape(-1, 2, 3) + s_group = torch.index_select(input=surf_edges_s, index=idx_group.reshape(-1), dim=0).reshape(-1, 2, 1) + + + zero_crossing_group = torch.index_select( + input=zero_crossing, index=idx_group.reshape(-1), dim=0).reshape(-1, 3) + + alpha_group = torch.index_select(input=alpha_nx12x2.reshape(-1, 2), dim=0, + index=edge_group_to_cube * 12 + edge_group).reshape(-1, 2, 1) + ue_group = self._linear_interp(s_group * alpha_group, x_group) + + beta_group = torch.gather(input=beta.reshape(-1), dim=0, + index=edge_group_to_cube * 12 + edge_group).reshape(-1, 1) + beta_sum = beta_sum.index_add_(0, index=edge_group_to_vd, source=beta_group) + vd = vd.index_add_(0, index=edge_group_to_vd, source=ue_group * beta_group) / beta_sum + + ''' + interpolate colors use the same method as dual vertices + ''' + if voxelgrid_colors is not None: + vd_color = torch.zeros((total_num_vd, C), device=self.device) + c_group = torch.index_select(input=surf_edges_c, index=idx_group.reshape(-1), dim=0).reshape(-1, 2, C) + uc_group = self._linear_interp(s_group * alpha_group, c_group) + vd_color = vd_color.index_add_(0, index=edge_group_to_vd, source=uc_group * beta_group) / beta_sum + else: + vd_color = None + + L_dev = self._compute_reg_loss(vd, zero_crossing_group, edge_group_to_vd, vd_num_edges) + + v_idx = torch.arange(vd.shape[0], device=self.device) # + total_num_vd + + vd_idx_map = (vd_idx_map.reshape(-1)).scatter(dim=0, index=edge_group_to_cube * + 12 + edge_group, src=v_idx[edge_group_to_vd]) + + return vd, L_dev, vd_gamma, vd_idx_map, vd_color + + def _triangulate(self, scalar_field, surf_edges, vd, vd_gamma, edge_counts, idx_map, vd_idx_map, surf_edges_mask, training, vd_color): + """ + Connects four neighboring dual vertices to form a quadrilateral. The quadrilaterals are then split into + triangles based on the gamma parameter, as described in Section 4.3. + """ + with torch.no_grad(): + group_mask = (edge_counts == 4) & surf_edges_mask # surface edges shared by 4 cubes. + group = idx_map.reshape(-1)[group_mask] + vd_idx = vd_idx_map[group_mask] + edge_indices, indices = torch.sort(group, stable=True) + quad_vd_idx = vd_idx[indices].reshape(-1, 4) + + # Ensure all face directions point towards the positive SDF to maintain consistent winding. + s_edges = scalar_field[surf_edges[edge_indices.reshape(-1, 4)[:, 0]].reshape(-1)].reshape(-1, 2) + flip_mask = s_edges[:, 0] > 0 + quad_vd_idx = torch.cat((quad_vd_idx[flip_mask][:, [0, 1, 3, 2]], + quad_vd_idx[~flip_mask][:, [2, 3, 1, 0]])) + + quad_gamma = torch.index_select(input=vd_gamma, index=quad_vd_idx.reshape(-1), dim=0).reshape(-1, 4) + gamma_02 = quad_gamma[:, 0] * quad_gamma[:, 2] + gamma_13 = quad_gamma[:, 1] * quad_gamma[:, 3] + if not training: + mask = (gamma_02 > gamma_13) + faces = torch.zeros((quad_gamma.shape[0], 6), dtype=torch.long, device=quad_vd_idx.device) + faces[mask] = quad_vd_idx[mask][:, self.quad_split_1] + faces[~mask] = quad_vd_idx[~mask][:, self.quad_split_2] + faces = faces.reshape(-1, 3) + else: + vd_quad = torch.index_select(input=vd, index=quad_vd_idx.reshape(-1), dim=0).reshape(-1, 4, 3) + vd_02 = (vd_quad[:, 0] + vd_quad[:, 2]) / 2 + vd_13 = (vd_quad[:, 1] + vd_quad[:, 3]) / 2 + weight_sum = (gamma_02 + gamma_13) + 1e-8 + vd_center = (vd_02 * gamma_02.unsqueeze(-1) + vd_13 * gamma_13.unsqueeze(-1)) / weight_sum.unsqueeze(-1) + + if vd_color is not None: + color_quad = torch.index_select(input=vd_color, index=quad_vd_idx.reshape(-1), dim=0).reshape(-1, 4, vd_color.shape[-1]) + color_02 = (color_quad[:, 0] + color_quad[:, 2]) / 2 + color_13 = (color_quad[:, 1] + color_quad[:, 3]) / 2 + color_center = (color_02 * gamma_02.unsqueeze(-1) + color_13 * gamma_13.unsqueeze(-1)) / weight_sum.unsqueeze(-1) + vd_color = torch.cat([vd_color, color_center]) + + + vd_center_idx = torch.arange(vd_center.shape[0], device=self.device) + vd.shape[0] + vd = torch.cat([vd, vd_center]) + faces = quad_vd_idx[:, self.quad_split_train].reshape(-1, 4, 2) + faces = torch.cat([faces, vd_center_idx.reshape(-1, 1, 1).repeat(1, 4, 1)], -1).reshape(-1, 3) + return vd, faces, s_edges, edge_indices, vd_color \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/tables.py b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/tables.py new file mode 100644 index 0000000000000000000000000000000000000000..5873e7727b5595a1e4fbc3bd10ae5be8f3d06cca --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/flexicubes/tables.py @@ -0,0 +1,791 @@ +# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited. +dmc_table = [ +[[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 8, 9, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 4, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 4, 7, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 4, 5, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 4, 5, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[5, 7, 8, 9, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 5, 7, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 5, 7, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 5, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 8, 9, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 7, 8, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 4, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 4, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 9, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 8, 11, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 4, 5, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 4, 5, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[5, 7, 8, 9, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 5, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 5, 7, 8, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 5, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 8, 9, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 7, 8, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 4, 7, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 9, 10, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 4, 7, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 9, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 4, 5, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 4, 5, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[5, 7, 8, 9, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 5, 7, 9, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 5, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 5, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[8, 9, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 7, 8, -1, -1, -1, -1], [1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 4, 7, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 9, 10, 11, -1, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 7, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 9, -1, -1, -1, -1], [1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 8, 10, 11, -1, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 4, 5, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[5, 7, 8, 9, -1, -1, -1], [1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 5, 7, 9, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 5, 7, 8, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 8, 9, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 6, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 4, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [4, 6, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 4, 6, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 9, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 4, 5, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 4, 5, 8, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[5, 6, 8, 9, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 5, 6, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 5, 6, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 5, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 6, 7, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 6, 7, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 4, 6, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 4, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [2, 3, 4, 6, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 4, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 9, -1, -1, -1, -1], [2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 6, 7, 8, -1, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 4, 5, -1, -1, -1], [2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 4, 5, 6, 7, 8], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 5, 6, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 5, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 2, 3, 5, 6, 8], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 10, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 9, 10, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 8, 9, 10, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 6, 8, 11, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 4, 6, 11, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 9, 10, -1, -1, -1], [4, 6, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 4, 6, 9, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 9, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1]], +[[0, 2, 4, 5, 10, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 4, 5, 8, 10, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[5, 6, 8, 9, 11, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 5, 6, 9, 11, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 5, 6, 8, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 5, 6, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 6, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 6, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 6, 7, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[6, 7, 8, 9, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 4, 6, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 4, 6, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 4, 6, 8, 9, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 6, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 9, -1, -1, -1, -1], [1, 3, 6, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 6, 7, 8, 10, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 4, 5, 6, 7, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 6, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 5, 6, 8, 9, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 5, 6, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 8, 9, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 7, 8, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 4, 7, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 4, 7, 9, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 6, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [4, 6, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 4, 6, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 4, 6, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[6, 7, 8, 9, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 6, 7, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 6, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 6, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 11, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 8, 11, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 8, 9, 11, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 7, 8, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 4, 7, 11, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1]], +[[1, 2, 4, 7, 9, 11, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 6, 9, 10, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 8, 11, -1, -1, -1], [4, 6, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 4, 6, 10, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 4, 6, 8, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[6, 7, 8, 9, 10, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 6, 7, 9, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 6, 7, 8, 10, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 6, 7, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 5, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 5, 6, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 7, 8, -1, -1, -1, -1], [1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 4, 7, -1, -1, -1], [1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 5, 6, 9, -1, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 4, 5, 6, 7, 9], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 4, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [1, 2, 4, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 4, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 4, 6, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 6, 7, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 2, 3, 6, 7, 9], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 6, 7, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 5, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 5, 6, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 5, 6, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[5, 6, 8, 9, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 7, 8, -1, -1, -1, -1], [1, 3, 5, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 4, 5, 6, 7, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 5, 6, 9, 11, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 6, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 4, 6, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 4, 6, 8, 9, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 4, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 6, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 6, 7, 8, 9, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 6, 7, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 8, 9, -1, -1, -1], [5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 4, 5, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [4, 5, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 4, 5, 9, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 7, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [4, 7, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 4, 7, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 4, 7, 8, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[8, 9, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 5, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 5, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [2, 3, 5, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 5, 7, 8, 9, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 4, 5, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 4, 5, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [2, 3, 4, 5, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 4, 5, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 4, 7, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 4, 7, 8, 9, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 2, 3, 4, 7, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 7, 8, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 8, 9, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 2, 3, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 5, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [1, 2, 5, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 5, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 5, 7, 8, 9, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 4, 5, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 2, 3, 4, 5, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 4, 5, 8, 9, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 9, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 4, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [1, 2, 4, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 4, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 4, 7, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 2, 8, 9, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 2, 3, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 2, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 5, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 5, 7, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 5, 7, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[5, 7, 8, 9, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 4, 5, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 4, 5, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 4, 5, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 4, 7, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 4, 7, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 4, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[1, 3, 8, 9, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 1, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[0, 3, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], +[[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]] +] +num_vd_table = [0, 1, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 2, 2, +2, 1, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 2, 1, 2, 3, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 2, +1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 1, 1, 2, 2, 2, 1, 1, 2, 1, 2, 3, 2, 2, 1, 1, 1, 1, +1, 1, 2, 1, 1, 1, 2, 1, 2, 2, 2, 1, 1, 1, 1, 1, 2, 3, 2, 2, 2, 2, 2, 1, 3, 4, 2, +2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 2, 1, 1, 2, 2, 2, 2, 2, +3, 2, 1, 2, 1, 1, 1, 1, 1, 1, 2, 2, 3, 2, 3, 2, 4, 2, 2, 2, 2, 1, 2, 1, 2, 1, 1, +2, 1, 1, 2, 2, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, +1, 2, 1, 1, 1, 2, 2, 2, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, +1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, +1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0] +check_table = [ +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 1, 0, 0, 194], +[1, -1, 0, 0, 193], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 0, 1, 0, 164], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 0, -1, 0, 161], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 0, 0, 1, 152], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 0, 0, 1, 145], +[1, 0, 0, 1, 144], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 0, 0, -1, 137], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 0, 1, 0, 133], +[1, 0, 1, 0, 132], +[1, 1, 0, 0, 131], +[1, 1, 0, 0, 130], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 0, 0, 1, 100], +[0, 0, 0, 0, 0], +[1, 0, 0, 1, 98], +[0, 0, 0, 0, 0], +[1, 0, 0, 1, 96], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 0, 1, 0, 88], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 0, -1, 0, 82], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 0, 1, 0, 74], +[0, 0, 0, 0, 0], +[1, 0, 1, 0, 72], +[0, 0, 0, 0, 0], +[1, 0, 0, -1, 70], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, -1, 0, 0, 67], +[0, 0, 0, 0, 0], +[1, -1, 0, 0, 65], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 1, 0, 0, 56], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, -1, 0, 0, 52], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 1, 0, 0, 44], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 1, 0, 0, 40], +[0, 0, 0, 0, 0], +[1, 0, 0, -1, 38], +[1, 0, -1, 0, 37], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 0, -1, 0, 33], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, -1, 0, 0, 28], +[0, 0, 0, 0, 0], +[1, 0, -1, 0, 26], +[1, 0, 0, -1, 25], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, -1, 0, 0, 20], +[0, 0, 0, 0, 0], +[1, 0, -1, 0, 18], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 0, 0, -1, 9], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[1, 0, 0, -1, 6], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0], +[0, 0, 0, 0, 0] +] +tet_table = [ +[-1, -1, -1, -1, -1, -1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[1, 1, 1, 1, 1, 1], +[4, 4, 4, 4, 4, 4], +[0, 0, 0, 0, 0, 0], +[4, 0, 0, 4, 4, -1], +[1, 1, 1, 1, 1, 1], +[4, 4, 4, 4, 4, 4], +[0, 4, 0, 4, 4, -1], +[0, 0, 0, 0, 0, 0], +[1, 1, 1, 1, 1, 1], +[5, 5, 5, 5, 5, 5], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[1, 1, 1, 1, 1, 1], +[2, 2, 2, 2, 2, 2], +[0, 0, 0, 0, 0, 0], +[2, 0, 2, -1, 0, 2], +[1, 1, 1, 1, 1, 1], +[2, -1, 2, 4, 4, 2], +[0, 0, 0, 0, 0, 0], +[2, 0, 2, 4, 4, 2], +[1, 1, 1, 1, 1, 1], +[2, 4, 2, 4, 4, 2], +[0, 4, 0, 4, 4, 0], +[2, 0, 2, 0, 0, 2], +[1, 1, 1, 1, 1, 1], +[2, 5, 2, 5, 5, 2], +[0, 0, 0, 0, 0, 0], +[2, 0, 2, 0, 0, 2], +[1, 1, 1, 1, 1, 1], +[1, 1, 1, 1, 1, 1], +[0, 1, 1, -1, 0, 1], +[0, 0, 0, 0, 0, 0], +[2, 2, 2, 2, 2, 2], +[4, 1, 1, 4, 4, 1], +[0, 1, 1, 0, 0, 1], +[4, 0, 0, 4, 4, 0], +[2, 2, 2, 2, 2, 2], +[-1, 1, 1, 4, 4, 1], +[0, 1, 1, 4, 4, 1], +[0, 0, 0, 0, 0, 0], +[2, 2, 2, 2, 2, 2], +[5, 1, 1, 5, 5, 1], +[0, 1, 1, 0, 0, 1], +[0, 0, 0, 0, 0, 0], +[2, 2, 2, 2, 2, 2], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[8, 8, 8, 8, 8, 8], +[1, 1, 1, 4, 4, 1], +[0, 0, 0, 0, 0, 0], +[4, 0, 0, 4, 4, 0], +[4, 4, 4, 4, 4, 4], +[1, 1, 1, 4, 4, 1], +[0, 4, 0, 4, 4, 0], +[0, 0, 0, 0, 0, 0], +[4, 4, 4, 4, 4, 4], +[1, 1, 1, 5, 5, 1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[5, 5, 5, 5, 5, 5], +[6, 6, 6, 6, 6, 6], +[6, -1, 0, 6, 0, 6], +[6, 0, 0, 6, 0, 6], +[6, 1, 1, 6, 1, 6], +[4, 4, 4, 4, 4, 4], +[0, 0, 0, 0, 0, 0], +[4, 0, 0, 4, 4, 4], +[1, 1, 1, 1, 1, 1], +[6, 4, -1, 6, 4, 6], +[6, 4, 0, 6, 4, 6], +[6, 0, 0, 6, 0, 6], +[6, 1, 1, 6, 1, 6], +[5, 5, 5, 5, 5, 5], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[1, 1, 1, 1, 1, 1], +[2, 2, 2, 2, 2, 2], +[0, 0, 0, 0, 0, 0], +[2, 0, 2, 2, 0, 2], +[1, 1, 1, 1, 1, 1], +[2, 2, 2, 2, 2, 2], +[0, 0, 0, 0, 0, 0], +[2, 0, 2, 2, 2, 2], +[1, 1, 1, 1, 1, 1], +[2, 4, 2, 2, 4, 2], +[0, 4, 0, 4, 4, 0], +[2, 0, 2, 2, 0, 2], +[1, 1, 1, 1, 1, 1], +[2, 2, 2, 2, 2, 2], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[1, 1, 1, 1, 1, 1], +[6, 1, 1, 6, -1, 6], +[6, 1, 1, 6, 0, 6], +[6, 0, 0, 6, 0, 6], +[6, 2, 2, 6, 2, 6], +[4, 1, 1, 4, 4, 1], +[0, 1, 1, 0, 0, 1], +[4, 0, 0, 4, 4, 4], +[2, 2, 2, 2, 2, 2], +[6, 1, 1, 6, 4, 6], +[6, 1, 1, 6, 4, 6], +[6, 0, 0, 6, 0, 6], +[6, 2, 2, 6, 2, 6], +[5, 1, 1, 5, 5, 1], +[0, 1, 1, 0, 0, 1], +[0, 0, 0, 0, 0, 0], +[2, 2, 2, 2, 2, 2], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[6, 6, 6, 6, 6, 6], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[4, 4, 4, 4, 4, 4], +[1, 1, 1, 1, 4, 1], +[0, 4, 0, 4, 4, 0], +[0, 0, 0, 0, 0, 0], +[4, 4, 4, 4, 4, 4], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[0, 5, 0, 5, 0, 5], +[5, 5, 5, 5, 5, 5], +[5, 5, 5, 5, 5, 5], +[0, 5, 0, 5, 0, 5], +[-1, 5, 0, 5, 0, 5], +[1, 5, 1, 5, 1, 5], +[4, 5, -1, 5, 4, 5], +[0, 5, 0, 5, 0, 5], +[4, 5, 0, 5, 4, 5], +[1, 5, 1, 5, 1, 5], +[4, 4, 4, 4, 4, 4], +[0, 4, 0, 4, 4, 4], +[0, 0, 0, 0, 0, 0], +[1, 1, 1, 1, 1, 1], +[6, 6, 6, 6, 6, 6], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[1, 1, 1, 1, 1, 1], +[2, 5, 2, 5, -1, 5], +[0, 5, 0, 5, 0, 5], +[2, 5, 2, 5, 0, 5], +[1, 5, 1, 5, 1, 5], +[2, 5, 2, 5, 4, 5], +[0, 5, 0, 5, 0, 5], +[2, 5, 2, 5, 4, 5], +[1, 5, 1, 5, 1, 5], +[2, 4, 2, 4, 4, 2], +[0, 4, 0, 4, 4, 4], +[2, 0, 2, 0, 0, 2], +[1, 1, 1, 1, 1, 1], +[2, 6, 2, 6, 6, 2], +[0, 0, 0, 0, 0, 0], +[2, 0, 2, 0, 0, 2], +[1, 1, 1, 1, 1, 1], +[1, 1, 1, 1, 1, 1], +[0, 1, 1, 1, 0, 1], +[0, 0, 0, 0, 0, 0], +[2, 2, 2, 2, 2, 2], +[4, 1, 1, 1, 4, 1], +[0, 1, 1, 1, 0, 1], +[4, 0, 0, 4, 4, 0], +[2, 2, 2, 2, 2, 2], +[1, 1, 1, 1, 1, 1], +[0, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[2, 2, 2, 2, 2, 2], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[2, 2, 2, 2, 2, 2], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[5, 5, 5, 5, 5, 5], +[1, 1, 1, 1, 4, 1], +[0, 0, 0, 0, 0, 0], +[4, 0, 0, 4, 4, 0], +[4, 4, 4, 4, 4, 4], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[4, 4, 4, 4, 4, 4], +[1, 1, 1, 1, 1, 1], +[6, 0, 0, 6, 0, 6], +[0, 0, 0, 0, 0, 0], +[6, 6, 6, 6, 6, 6], +[5, 5, 5, 5, 5, 5], +[5, 5, 0, 5, 0, 5], +[5, 5, 0, 5, 0, 5], +[5, 5, 1, 5, 1, 5], +[4, 4, 4, 4, 4, 4], +[0, 0, 0, 0, 0, 0], +[4, 4, 0, 4, 4, 4], +[1, 1, 1, 1, 1, 1], +[4, 4, 4, 4, 4, 4], +[4, 4, 0, 4, 4, 4], +[0, 0, 0, 0, 0, 0], +[1, 1, 1, 1, 1, 1], +[8, 8, 8, 8, 8, 8], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[1, 1, 1, 1, 1, 1], +[2, 2, 2, 2, 2, 2], +[0, 0, 0, 0, 0, 0], +[2, 2, 2, 2, 0, 2], +[1, 1, 1, 1, 1, 1], +[2, 2, 2, 2, 2, 2], +[0, 0, 0, 0, 0, 0], +[2, 2, 2, 2, 2, 2], +[1, 1, 1, 1, 1, 1], +[2, 2, 2, 2, 2, 2], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[4, 1, 1, 4, 4, 1], +[2, 2, 2, 2, 2, 2], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[1, 1, 1, 1, 1, 1], +[1, 1, 1, 1, 1, 1], +[1, 1, 1, 1, 0, 1], +[0, 0, 0, 0, 0, 0], +[2, 2, 2, 2, 2, 2], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[2, 4, 2, 4, 4, 2], +[1, 1, 1, 1, 1, 1], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[2, 2, 2, 2, 2, 2], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[2, 2, 2, 2, 2, 2], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[5, 5, 5, 5, 5, 5], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[4, 4, 4, 4, 4, 4], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[4, 4, 4, 4, 4, 4], +[1, 1, 1, 1, 1, 1], +[0, 0, 0, 0, 0, 0], +[0, 0, 0, 0, 0, 0], +[12, 12, 12, 12, 12, 12] +] diff --git a/thirdparty/TRELLIS/trellis/representations/mesh/utils_cube.py b/thirdparty/TRELLIS/trellis/representations/mesh/utils_cube.py new file mode 100644 index 0000000000000000000000000000000000000000..23913c97bb2d57dfa0384667c69f9860ea0a4155 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/mesh/utils_cube.py @@ -0,0 +1,61 @@ +import torch +cube_corners = torch.tensor([[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [ + 1, 0, 1], [0, 1, 1], [1, 1, 1]], dtype=torch.int) +cube_neighbor = torch.tensor([[1, 0, 0], [-1, 0, 0], [0, 1, 0], [0, -1, 0], [0, 0, 1], [0, 0, -1]]) +cube_edges = torch.tensor([0, 1, 1, 5, 4, 5, 0, 4, 2, 3, 3, 7, 6, 7, 2, 6, + 2, 0, 3, 1, 7, 5, 6, 4], dtype=torch.long, requires_grad=False) + +def construct_dense_grid(res, device='cuda'): + '''construct a dense grid based on resolution''' + res_v = res + 1 + vertsid = torch.arange(res_v ** 3, device=device) + coordsid = vertsid.reshape(res_v, res_v, res_v)[:res, :res, :res].flatten() + cube_corners_bias = (cube_corners[:, 0] * res_v + cube_corners[:, 1]) * res_v + cube_corners[:, 2] + cube_fx8 = (coordsid.unsqueeze(1) + cube_corners_bias.unsqueeze(0).to(device)) + verts = torch.stack([vertsid // (res_v ** 2), (vertsid // res_v) % res_v, vertsid % res_v], dim=1) + return verts, cube_fx8 + + +def construct_voxel_grid(coords): + verts = (cube_corners.unsqueeze(0).to(coords) + coords.unsqueeze(1)).reshape(-1, 3) + verts_unique, inverse_indices = torch.unique(verts, dim=0, return_inverse=True) + cubes = inverse_indices.reshape(-1, 8) + return verts_unique, cubes + + +def cubes_to_verts(num_verts, cubes, value, reduce='mean'): + """ + Args: + cubes [Vx8] verts index for each cube + value [Vx8xM] value to be scattered + Operation: + reduced[cubes[i][j]][k] += value[i][k] + """ + M = value.shape[2] # number of channels + reduced = torch.zeros(num_verts, M, device=cubes.device) + return torch.scatter_reduce(reduced, 0, + cubes.unsqueeze(-1).expand(-1, -1, M).flatten(0, 1), + value.flatten(0, 1), reduce=reduce, include_self=False) + +def sparse_cube2verts(coords, feats, training=True): + new_coords, cubes = construct_voxel_grid(coords) + new_feats = cubes_to_verts(new_coords.shape[0], cubes, feats) + if training: + con_loss = torch.mean((feats - new_feats[cubes]) ** 2) + else: + con_loss = 0.0 + return new_coords, new_feats, con_loss + + +def get_dense_attrs(coords : torch.Tensor, feats : torch.Tensor, res : int, sdf_init=True): + F = feats.shape[-1] + dense_attrs = torch.zeros([res] * 3 + [F], device=feats.device) + if sdf_init: + dense_attrs[..., 0] = 1 # initial outside sdf value + dense_attrs[coords[:, 0], coords[:, 1], coords[:, 2], :] = feats + return dense_attrs.reshape(-1, F) + + +def get_defomed_verts(v_pos : torch.Tensor, deform : torch.Tensor, res): + return v_pos / res - 0.5 + (1 - 1e-8) / (res * 2) * torch.tanh(deform) + \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/representations/octree/__init__.py b/thirdparty/TRELLIS/trellis/representations/octree/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..f66a39a5a7498e2e99fe9d94d663796b3bc157b5 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/octree/__init__.py @@ -0,0 +1 @@ +from .octree_dfs import DfsOctree \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/representations/octree/octree_dfs.py b/thirdparty/TRELLIS/trellis/representations/octree/octree_dfs.py new file mode 100755 index 0000000000000000000000000000000000000000..9d1f7898f30414f304953cfb2d51d00511ec8325 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/octree/octree_dfs.py @@ -0,0 +1,362 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + + +DEFAULT_TRIVEC_CONFIG = { + 'dim': 8, + 'rank': 8, +} + +DEFAULT_VOXEL_CONFIG = { + 'solid': False, +} + +DEFAULT_DECOPOLY_CONFIG = { + 'degree': 8, + 'rank': 16, +} + + +class DfsOctree: + """ + Sparse Voxel Octree (SVO) implementation for PyTorch. + Using Depth-First Search (DFS) order to store the octree. + DFS order suits rendering and ray tracing. + + The structure and data are separatedly stored. + Structure is stored as a continuous array, each element is a 3*32 bits descriptor. + |-----------------------------------------| + | 0:3 bits | 4:31 bits | + | leaf num | unused | + |-----------------------------------------| + | 0:31 bits | + | child ptr | + |-----------------------------------------| + | 0:31 bits | + | data ptr | + |-----------------------------------------| + Each element represents a non-leaf node in the octree. + The valid mask is used to indicate whether the children are valid. + The leaf mask is used to indicate whether the children are leaf nodes. + The child ptr is used to point to the first non-leaf child. Non-leaf children descriptors are stored continuously from the child ptr. + The data ptr is used to point to the data of leaf children. Leaf children data are stored continuously from the data ptr. + + There are also auxiliary arrays to store the additional structural information to facilitate parallel processing. + - Position: the position of the octree nodes. + - Depth: the depth of the octree nodes. + + Args: + depth (int): the depth of the octree. + """ + + def __init__( + self, + depth, + aabb=[0,0,0,1,1,1], + sh_degree=2, + primitive='voxel', + primitive_config={}, + device='cuda', + ): + self.max_depth = depth + self.aabb = torch.tensor(aabb, dtype=torch.float32, device=device) + self.device = device + self.sh_degree = sh_degree + self.active_sh_degree = sh_degree + self.primitive = primitive + self.primitive_config = primitive_config + + self.structure = torch.tensor([[8, 1, 0]], dtype=torch.int32, device=self.device) + self.position = torch.zeros((8, 3), dtype=torch.float32, device=self.device) + self.depth = torch.zeros((8, 1), dtype=torch.uint8, device=self.device) + self.position[:, 0] = torch.tensor([0.25, 0.75, 0.25, 0.75, 0.25, 0.75, 0.25, 0.75], device=self.device) + self.position[:, 1] = torch.tensor([0.25, 0.25, 0.75, 0.75, 0.25, 0.25, 0.75, 0.75], device=self.device) + self.position[:, 2] = torch.tensor([0.25, 0.25, 0.25, 0.25, 0.75, 0.75, 0.75, 0.75], device=self.device) + self.depth[:, 0] = 1 + + self.data = ['position', 'depth'] + self.param_names = [] + + if primitive == 'voxel': + self.features_dc = torch.zeros((8, 1, 3), dtype=torch.float32, device=self.device) + self.features_ac = torch.zeros((8, (sh_degree+1)**2-1, 3), dtype=torch.float32, device=self.device) + self.data += ['features_dc', 'features_ac'] + self.param_names += ['features_dc', 'features_ac'] + if not primitive_config.get('solid', False): + self.density = torch.zeros((8, 1), dtype=torch.float32, device=self.device) + self.data.append('density') + self.param_names.append('density') + elif primitive == 'gaussian': + self.features_dc = torch.zeros((8, 1, 3), dtype=torch.float32, device=self.device) + self.features_ac = torch.zeros((8, (sh_degree+1)**2-1, 3), dtype=torch.float32, device=self.device) + self.opacity = torch.zeros((8, 1), dtype=torch.float32, device=self.device) + self.data += ['features_dc', 'features_ac', 'opacity'] + self.param_names += ['features_dc', 'features_ac', 'opacity'] + elif primitive == 'trivec': + self.trivec = torch.zeros((8, primitive_config['rank'], 3, primitive_config['dim']), dtype=torch.float32, device=self.device) + self.density = torch.zeros((8, primitive_config['rank']), dtype=torch.float32, device=self.device) + self.features_dc = torch.zeros((8, primitive_config['rank'], 1, 3), dtype=torch.float32, device=self.device) + self.features_ac = torch.zeros((8, primitive_config['rank'], (sh_degree+1)**2-1, 3), dtype=torch.float32, device=self.device) + self.density_shift = 0 + self.data += ['trivec', 'density', 'features_dc', 'features_ac'] + self.param_names += ['trivec', 'density', 'features_dc', 'features_ac'] + elif primitive == 'decoupoly': + self.decoupoly_V = torch.zeros((8, primitive_config['rank'], 3), dtype=torch.float32, device=self.device) + self.decoupoly_g = torch.zeros((8, primitive_config['rank'], primitive_config['degree']), dtype=torch.float32, device=self.device) + self.density = torch.zeros((8, primitive_config['rank']), dtype=torch.float32, device=self.device) + self.features_dc = torch.zeros((8, primitive_config['rank'], 1, 3), dtype=torch.float32, device=self.device) + self.features_ac = torch.zeros((8, primitive_config['rank'], (sh_degree+1)**2-1, 3), dtype=torch.float32, device=self.device) + self.density_shift = 0 + self.data += ['decoupoly_V', 'decoupoly_g', 'density', 'features_dc', 'features_ac'] + self.param_names += ['decoupoly_V', 'decoupoly_g', 'density', 'features_dc', 'features_ac'] + + self.setup_functions() + + def setup_functions(self): + self.density_activation = (lambda x: torch.exp(x - 2)) if self.primitive != 'trivec' else (lambda x: x) + self.opacity_activation = lambda x: torch.sigmoid(x - 6) + self.inverse_opacity_activation = lambda x: torch.log(x / (1 - x)) + 6 + self.color_activation = lambda x: torch.sigmoid(x) + + @property + def num_non_leaf_nodes(self): + return self.structure.shape[0] + + @property + def num_leaf_nodes(self): + return self.depth.shape[0] + + @property + def cur_depth(self): + return self.depth.max().item() + + @property + def occupancy(self): + return self.num_leaf_nodes / 8 ** self.cur_depth + + @property + def get_xyz(self): + return self.position + + @property + def get_depth(self): + return self.depth + + @property + def get_density(self): + if self.primitive == 'voxel' and self.voxel_config['solid']: + return torch.full((self.position.shape[0], 1), 1000, dtype=torch.float32, device=self.device) + return self.density_activation(self.density) + + @property + def get_opacity(self): + return self.opacity_activation(self.density) + + @property + def get_trivec(self): + return self.trivec + + @property + def get_decoupoly(self): + return F.normalize(self.decoupoly_V, dim=-1), self.decoupoly_g + + @property + def get_color(self): + return self.color_activation(self.colors) + + @property + def get_features(self): + if self.sh_degree == 0: + return self.features_dc + return torch.cat([self.features_dc, self.features_ac], dim=-2) + + def state_dict(self): + ret = {'structure': self.structure, 'position': self.position, 'depth': self.depth, 'sh_degree': self.sh_degree, 'active_sh_degree': self.active_sh_degree, 'trivec_config': self.trivec_config, 'voxel_config': self.voxel_config, 'primitive': self.primitive} + if hasattr(self, 'density_shift'): + ret['density_shift'] = self.density_shift + for data in set(self.data + self.param_names): + if not isinstance(getattr(self, data), nn.Module): + ret[data] = getattr(self, data) + else: + ret[data] = getattr(self, data).state_dict() + return ret + + def load_state_dict(self, state_dict): + keys = list(set(self.data + self.param_names + list(state_dict.keys()) + ['structure', 'position', 'depth'])) + for key in keys: + if key not in state_dict: + print(f"Warning: key {key} not found in the state_dict.") + continue + try: + if not isinstance(getattr(self, key), nn.Module): + setattr(self, key, state_dict[key]) + else: + getattr(self, key).load_state_dict(state_dict[key]) + except Exception as e: + print(e) + raise ValueError(f"Error loading key {key}.") + + def gather_from_leaf_children(self, data): + """ + Gather the data from the leaf children. + + Args: + data (torch.Tensor): the data to gather. The first dimension should be the number of leaf nodes. + """ + leaf_cnt = self.structure[:, 0] + leaf_cnt_masks = [leaf_cnt == i for i in range(1, 9)] + ret = torch.zeros((self.num_non_leaf_nodes,), dtype=data.dtype, device=self.device) + for i in range(8): + if leaf_cnt_masks[i].sum() == 0: + continue + start = self.structure[leaf_cnt_masks[i], 2] + for j in range(i+1): + ret[leaf_cnt_masks[i]] += data[start + j] + return ret + + def gather_from_non_leaf_children(self, data): + """ + Gather the data from the non-leaf children. + + Args: + data (torch.Tensor): the data to gather. The first dimension should be the number of leaf nodes. + """ + non_leaf_cnt = 8 - self.structure[:, 0] + non_leaf_cnt_masks = [non_leaf_cnt == i for i in range(1, 9)] + ret = torch.zeros_like(data, device=self.device) + for i in range(8): + if non_leaf_cnt_masks[i].sum() == 0: + continue + start = self.structure[non_leaf_cnt_masks[i], 1] + for j in range(i+1): + ret[non_leaf_cnt_masks[i]] += data[start + j] + return ret + + def structure_control(self, mask): + """ + Control the structure of the octree. + + Args: + mask (torch.Tensor): the mask to control the structure. 1 for subdivide, -1 for merge, 0 for keep. + """ + # Dont subdivide when the depth is the maximum. + mask[self.depth.squeeze() == self.max_depth] = torch.clamp_max(mask[self.depth.squeeze() == self.max_depth], 0) + # Dont merge when the depth is the minimum. + mask[self.depth.squeeze() == 1] = torch.clamp_min(mask[self.depth.squeeze() == 1], 0) + + # Gather control mask + structre_ctrl = self.gather_from_leaf_children(mask) + structre_ctrl[structre_ctrl==-8] = -1 + + new_leaf_num = self.structure[:, 0].clone() + # Modify the leaf num. + structre_valid = structre_ctrl >= 0 + new_leaf_num[structre_valid] -= structre_ctrl[structre_valid] # Add the new nodes. + structre_delete = structre_ctrl < 0 + merged_nodes = self.gather_from_non_leaf_children(structre_delete.int()) + new_leaf_num += merged_nodes # Delete the merged nodes. + + # Update the structure array to allocate new nodes. + mem_offset = torch.zeros((self.num_non_leaf_nodes + 1,), dtype=torch.int32, device=self.device) + mem_offset.index_add_(0, self.structure[structre_valid, 1], structre_ctrl[structre_valid]) # Add the new nodes. + mem_offset[:-1] -= structre_delete.int() # Delete the merged nodes. + new_structre_idx = torch.arange(0, self.num_non_leaf_nodes + 1, dtype=torch.int32, device=self.device) + mem_offset.cumsum(0) + new_structure_length = new_structre_idx[-1].item() + new_structre_idx = new_structre_idx[:-1] + new_structure = torch.empty((new_structure_length, 3), dtype=torch.int32, device=self.device) + new_structure[new_structre_idx[structre_valid], 0] = new_leaf_num[structre_valid] + + # Initialize the new nodes. + new_node_mask = torch.ones((new_structure_length,), dtype=torch.bool, device=self.device) + new_node_mask[new_structre_idx[structre_valid]] = False + new_structure[new_node_mask, 0] = 8 # Initialize to all leaf nodes. + new_node_num = new_node_mask.sum().item() + + # Rebuild child ptr. + non_leaf_cnt = 8 - new_structure[:, 0] + new_child_ptr = torch.cat([torch.zeros((1,), dtype=torch.int32, device=self.device), non_leaf_cnt.cumsum(0)[:-1]]) + new_structure[:, 1] = new_child_ptr + 1 + + # Rebuild data ptr with old data. + leaf_cnt = torch.zeros((new_structure_length,), dtype=torch.int32, device=self.device) + leaf_cnt.index_add_(0, new_structre_idx, self.structure[:, 0]) + old_data_ptr = torch.cat([torch.zeros((1,), dtype=torch.int32, device=self.device), leaf_cnt.cumsum(0)[:-1]]) + + # Update the data array + subdivide_mask = mask == 1 + merge_mask = mask == -1 + data_valid = ~(subdivide_mask | merge_mask) + mem_offset = torch.zeros((self.num_leaf_nodes + 1,), dtype=torch.int32, device=self.device) + mem_offset.index_add_(0, old_data_ptr[new_node_mask], torch.full((new_node_num,), 8, dtype=torch.int32, device=self.device)) # Add data array for new nodes + mem_offset[:-1] -= subdivide_mask.int() # Delete data elements for subdivide nodes + mem_offset[:-1] -= merge_mask.int() # Delete data elements for merge nodes + mem_offset.index_add_(0, self.structure[structre_valid, 2], merged_nodes[structre_valid]) # Add data elements for merge nodes + new_data_idx = torch.arange(0, self.num_leaf_nodes + 1, dtype=torch.int32, device=self.device) + mem_offset.cumsum(0) + new_data_length = new_data_idx[-1].item() + new_data_idx = new_data_idx[:-1] + new_data = {data: torch.empty((new_data_length,) + getattr(self, data).shape[1:], dtype=getattr(self, data).dtype, device=self.device) for data in self.data} + for data in self.data: + new_data[data][new_data_idx[data_valid]] = getattr(self, data)[data_valid] + + # Rebuild data ptr + leaf_cnt = new_structure[:, 0] + new_data_ptr = torch.cat([torch.zeros((1,), dtype=torch.int32, device=self.device), leaf_cnt.cumsum(0)[:-1]]) + new_structure[:, 2] = new_data_ptr + + # Initialize the new data array + ## For subdivide nodes + if subdivide_mask.sum() > 0: + subdivide_data_ptr = new_structure[new_node_mask, 2] + for data in self.data: + for i in range(8): + if data == 'position': + offset = torch.tensor([i // 4, (i // 2) % 2, i % 2], dtype=torch.float32, device=self.device) - 0.5 + scale = 2 ** (-1.0 - self.depth[subdivide_mask]) + new_data['position'][subdivide_data_ptr + i] = self.position[subdivide_mask] + offset * scale + elif data == 'depth': + new_data['depth'][subdivide_data_ptr + i] = self.depth[subdivide_mask] + 1 + elif data == 'opacity': + new_data['opacity'][subdivide_data_ptr + i] = self.inverse_opacity_activation(torch.sqrt(self.opacity_activation(self.opacity[subdivide_mask]))) + elif data == 'trivec': + offset = torch.tensor([i // 4, (i // 2) % 2, i % 2], dtype=torch.float32, device=self.device) * 0.5 + coord = (torch.linspace(0, 0.5, self.trivec.shape[-1], dtype=torch.float32, device=self.device)[None] + offset[:, None]).reshape(1, 3, self.trivec.shape[-1], 1) + axis = torch.linspace(0, 1, 3, dtype=torch.float32, device=self.device).reshape(1, 3, 1, 1).repeat(1, 1, self.trivec.shape[-1], 1) + coord = torch.stack([coord, axis], dim=3).reshape(1, 3, self.trivec.shape[-1], 2).expand(self.trivec[subdivide_mask].shape[0], -1, -1, -1) * 2 - 1 + new_data['trivec'][subdivide_data_ptr + i] = F.grid_sample(self.trivec[subdivide_mask], coord, align_corners=True) + else: + new_data[data][subdivide_data_ptr + i] = getattr(self, data)[subdivide_mask] + ## For merge nodes + if merge_mask.sum() > 0: + merge_data_ptr = torch.empty((merged_nodes.sum().item(),), dtype=torch.int32, device=self.device) + merge_nodes_cumsum = torch.cat([torch.zeros((1,), dtype=torch.int32, device=self.device), merged_nodes.cumsum(0)[:-1]]) + for i in range(8): + merge_data_ptr[merge_nodes_cumsum[merged_nodes > i] + i] = new_structure[new_structre_idx[merged_nodes > i], 2] + i + old_merge_data_ptr = self.structure[structre_delete, 2] + for data in self.data: + if data == 'position': + scale = 2 ** (1.0 - self.depth[old_merge_data_ptr]) + new_data['position'][merge_data_ptr] = ((self.position[old_merge_data_ptr] + 0.5) / scale).floor() * scale + 0.5 * scale - 0.5 + elif data == 'depth': + new_data['depth'][merge_data_ptr] = self.depth[old_merge_data_ptr] - 1 + elif data == 'opacity': + new_data['opacity'][subdivide_data_ptr + i] = self.inverse_opacity_activation(self.opacity_activation(self.opacity[subdivide_mask])**2) + elif data == 'trivec': + new_data['trivec'][merge_data_ptr] = self.trivec[old_merge_data_ptr] + else: + new_data[data][merge_data_ptr] = getattr(self, data)[old_merge_data_ptr] + + # Update the structure and data array + self.structure = new_structure + for data in self.data: + setattr(self, data, new_data[data]) + + # Save data array control temp variables + self.data_rearrange_buffer = { + 'subdivide_mask': subdivide_mask, + 'merge_mask': merge_mask, + 'data_valid': data_valid, + 'new_data_idx': new_data_idx, + 'new_data_length': new_data_length, + 'new_data': new_data + } diff --git a/thirdparty/TRELLIS/trellis/representations/radiance_field/__init__.py b/thirdparty/TRELLIS/trellis/representations/radiance_field/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..b72a1b7e76b509ee5a5e6979858eb17b4158a151 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/radiance_field/__init__.py @@ -0,0 +1 @@ +from .strivec import Strivec \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/representations/radiance_field/strivec.py b/thirdparty/TRELLIS/trellis/representations/radiance_field/strivec.py new file mode 100644 index 0000000000000000000000000000000000000000..8fc4b749786d934dae82864b560baccd91fcabbc --- /dev/null +++ b/thirdparty/TRELLIS/trellis/representations/radiance_field/strivec.py @@ -0,0 +1,28 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +from ..octree import DfsOctree as Octree + + +class Strivec(Octree): + def __init__( + self, + resolution: int, + aabb: list, + sh_degree: int = 0, + rank: int = 8, + dim: int = 8, + device: str = "cuda", + ): + assert np.log2(resolution) % 1 == 0, "Resolution must be a power of 2" + self.resolution = resolution + depth = int(np.round(np.log2(resolution))) + super().__init__( + depth=depth, + aabb=aabb, + sh_degree=sh_degree, + primitive="trivec", + primitive_config={"rank": rank, "dim": dim}, + device=device, + ) diff --git a/thirdparty/TRELLIS/trellis/utils/__init__.py b/thirdparty/TRELLIS/trellis/utils/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/thirdparty/TRELLIS/trellis/utils/general_utils.py b/thirdparty/TRELLIS/trellis/utils/general_utils.py new file mode 100755 index 0000000000000000000000000000000000000000..3b454d9c75521e33466055fe37c3fc1e37180a79 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/utils/general_utils.py @@ -0,0 +1,187 @@ +import numpy as np +import cv2 +import torch + + +# Dictionary utils +def _dict_merge(dicta, dictb, prefix=''): + """ + Merge two dictionaries. + """ + assert isinstance(dicta, dict), 'input must be a dictionary' + assert isinstance(dictb, dict), 'input must be a dictionary' + dict_ = {} + all_keys = set(dicta.keys()).union(set(dictb.keys())) + for key in all_keys: + if key in dicta.keys() and key in dictb.keys(): + if isinstance(dicta[key], dict) and isinstance(dictb[key], dict): + dict_[key] = _dict_merge(dicta[key], dictb[key], prefix=f'{prefix}.{key}') + else: + raise ValueError(f'Duplicate key {prefix}.{key} found in both dictionaries. Types: {type(dicta[key])}, {type(dictb[key])}') + elif key in dicta.keys(): + dict_[key] = dicta[key] + else: + dict_[key] = dictb[key] + return dict_ + + +def dict_merge(dicta, dictb): + """ + Merge two dictionaries. + """ + return _dict_merge(dicta, dictb, prefix='') + + +def dict_foreach(dic, func, special_func={}): + """ + Recursively apply a function to all non-dictionary leaf values in a dictionary. + """ + assert isinstance(dic, dict), 'input must be a dictionary' + for key in dic.keys(): + if isinstance(dic[key], dict): + dic[key] = dict_foreach(dic[key], func) + else: + if key in special_func.keys(): + dic[key] = special_func[key](dic[key]) + else: + dic[key] = func(dic[key]) + return dic + + +def dict_reduce(dicts, func, special_func={}): + """ + Reduce a list of dictionaries. Leaf values must be scalars. + """ + assert isinstance(dicts, list), 'input must be a list of dictionaries' + assert all([isinstance(d, dict) for d in dicts]), 'input must be a list of dictionaries' + assert len(dicts) > 0, 'input must be a non-empty list of dictionaries' + all_keys = set([key for dict_ in dicts for key in dict_.keys()]) + reduced_dict = {} + for key in all_keys: + vlist = [dict_[key] for dict_ in dicts if key in dict_.keys()] + if isinstance(vlist[0], dict): + reduced_dict[key] = dict_reduce(vlist, func, special_func) + else: + if key in special_func.keys(): + reduced_dict[key] = special_func[key](vlist) + else: + reduced_dict[key] = func(vlist) + return reduced_dict + + +def dict_any(dic, func): + """ + Recursively apply a function to all non-dictionary leaf values in a dictionary. + """ + assert isinstance(dic, dict), 'input must be a dictionary' + for key in dic.keys(): + if isinstance(dic[key], dict): + if dict_any(dic[key], func): + return True + else: + if func(dic[key]): + return True + return False + + +def dict_all(dic, func): + """ + Recursively apply a function to all non-dictionary leaf values in a dictionary. + """ + assert isinstance(dic, dict), 'input must be a dictionary' + for key in dic.keys(): + if isinstance(dic[key], dict): + if not dict_all(dic[key], func): + return False + else: + if not func(dic[key]): + return False + return True + + +def dict_flatten(dic, sep='.'): + """ + Flatten a nested dictionary into a dictionary with no nested dictionaries. + """ + assert isinstance(dic, dict), 'input must be a dictionary' + flat_dict = {} + for key in dic.keys(): + if isinstance(dic[key], dict): + sub_dict = dict_flatten(dic[key], sep=sep) + for sub_key in sub_dict.keys(): + flat_dict[str(key) + sep + str(sub_key)] = sub_dict[sub_key] + else: + flat_dict[key] = dic[key] + return flat_dict + + +def make_grid(images, nrow=None, ncol=None, aspect_ratio=None): + num_images = len(images) + if nrow is None and ncol is None: + if aspect_ratio is not None: + nrow = int(np.round(np.sqrt(num_images / aspect_ratio))) + else: + nrow = int(np.sqrt(num_images)) + ncol = (num_images + nrow - 1) // nrow + elif nrow is None and ncol is not None: + nrow = (num_images + ncol - 1) // ncol + elif nrow is not None and ncol is None: + ncol = (num_images + nrow - 1) // nrow + else: + assert nrow * ncol >= num_images, 'nrow * ncol must be greater than or equal to the number of images' + + grid = np.zeros((nrow * images[0].shape[0], ncol * images[0].shape[1], images[0].shape[2]), dtype=images[0].dtype) + for i, img in enumerate(images): + row = i // ncol + col = i % ncol + grid[row * img.shape[0]:(row + 1) * img.shape[0], col * img.shape[1]:(col + 1) * img.shape[1]] = img + return grid + + +def notes_on_image(img, notes=None): + img = np.pad(img, ((0, 32), (0, 0), (0, 0)), 'constant', constant_values=0) + img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) + if notes is not None: + img = cv2.putText(img, notes, (0, img.shape[0] - 4), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 1) + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + return img + + +def save_image_with_notes(img, path, notes=None): + """ + Save an image with notes. + """ + if isinstance(img, torch.Tensor): + img = img.cpu().numpy().transpose(1, 2, 0) + if img.dtype == np.float32 or img.dtype == np.float64: + img = np.clip(img * 255, 0, 255).astype(np.uint8) + img = notes_on_image(img, notes) + cv2.imwrite(path, cv2.cvtColor(img, cv2.COLOR_RGB2BGR)) + + +# debug utils + +def atol(x, y): + """ + Absolute tolerance. + """ + return torch.abs(x - y) + + +def rtol(x, y): + """ + Relative tolerance. + """ + return torch.abs(x - y) / torch.clamp_min(torch.maximum(torch.abs(x), torch.abs(y)), 1e-12) + + +# print utils +def indent(s, n=4): + """ + Indent a string. + """ + lines = s.split('\n') + for i in range(1, len(lines)): + lines[i] = ' ' * n + lines[i] + return '\n'.join(lines) + diff --git a/thirdparty/TRELLIS/trellis/utils/postprocessing_utils.py b/thirdparty/TRELLIS/trellis/utils/postprocessing_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..0a8d9fb79ad73effecc9ebcbfe241a12f8022e0f --- /dev/null +++ b/thirdparty/TRELLIS/trellis/utils/postprocessing_utils.py @@ -0,0 +1,587 @@ +from typing import * +import numpy as np +import torch +import utils3d +import nvdiffrast.torch as dr +from tqdm import tqdm +import trimesh +import trimesh.visual +import xatlas +import pyvista as pv +from pymeshfix import _meshfix +import igraph +import cv2 +from PIL import Image +from .random_utils import sphere_hammersley_sequence +from .render_utils import render_multiview +from ..renderers import GaussianRenderer +from ..representations import Strivec, Gaussian, MeshExtractResult + + +@torch.no_grad() +def _fill_holes( + verts, + faces, + max_hole_size=0.04, + max_hole_nbe=32, + resolution=128, + num_views=500, + debug=False, + verbose=False +): + """ + Rasterize a mesh from multiple views and remove invisible faces. + Also includes postprocessing to: + 1. Remove connected components that are have low visibility. + 2. Mincut to remove faces at the inner side of the mesh connected to the outer side with a small hole. + + Args: + verts (torch.Tensor): Vertices of the mesh. Shape (V, 3). + faces (torch.Tensor): Faces of the mesh. Shape (F, 3). + max_hole_size (float): Maximum area of a hole to fill. + resolution (int): Resolution of the rasterization. + num_views (int): Number of views to rasterize the mesh. + verbose (bool): Whether to print progress. + """ + # Construct cameras + yaws = [] + pitchs = [] + for i in range(num_views): + y, p = sphere_hammersley_sequence(i, num_views) + yaws.append(y) + pitchs.append(p) + yaws = torch.tensor(yaws).cuda() + pitchs = torch.tensor(pitchs).cuda() + radius = 2.0 + fov = torch.deg2rad(torch.tensor(40)).cuda() + projection = utils3d.torch.perspective_from_fov_xy(fov, fov, 1, 3) + views = [] + for (yaw, pitch) in zip(yaws, pitchs): + orig = torch.tensor([ + torch.sin(yaw) * torch.cos(pitch), + torch.cos(yaw) * torch.cos(pitch), + torch.sin(pitch), + ]).cuda().float() * radius + view = utils3d.torch.view_look_at(orig, torch.tensor([0, 0, 0]).float().cuda(), torch.tensor([0, 0, 1]).float().cuda()) + views.append(view) + views = torch.stack(views, dim=0) + + # Rasterize + visblity = torch.zeros(faces.shape[0], dtype=torch.int32, device=verts.device) + rastctx = utils3d.torch.RastContext(backend='cuda') + for i in tqdm(range(views.shape[0]), total=views.shape[0], disable=not verbose, desc='Rasterizing'): + view = views[i] + buffers = utils3d.torch.rasterize_triangle_faces( + rastctx, verts[None], faces, resolution, resolution, view=view, projection=projection + ) + face_id = buffers['face_id'][0][buffers['mask'][0] > 0.95] - 1 + face_id = torch.unique(face_id).long() + visblity[face_id] += 1 + visblity = visblity.float() / num_views + + # Mincut + ## construct outer faces + edges, face2edge, edge_degrees = utils3d.torch.compute_edges(faces) + boundary_edge_indices = torch.nonzero(edge_degrees == 1).reshape(-1) + connected_components = utils3d.torch.compute_connected_components(faces, edges, face2edge) + outer_face_indices = torch.zeros(faces.shape[0], dtype=torch.bool, device=faces.device) + for i in range(len(connected_components)): + outer_face_indices[connected_components[i]] = visblity[connected_components[i]] > min(max(visblity[connected_components[i]].quantile(0.75).item(), 0.25), 0.5) + outer_face_indices = outer_face_indices.nonzero().reshape(-1) + + ## construct inner faces + inner_face_indices = torch.nonzero(visblity == 0).reshape(-1) + if verbose: + tqdm.write(f'Found {inner_face_indices.shape[0]} invisible faces') + if inner_face_indices.shape[0] == 0: + return verts, faces + + ## Construct dual graph (faces as nodes, edges as edges) + dual_edges, dual_edge2edge = utils3d.torch.compute_dual_graph(face2edge) + dual_edge2edge = edges[dual_edge2edge] + dual_edges_weights = torch.norm(verts[dual_edge2edge[:, 0]] - verts[dual_edge2edge[:, 1]], dim=1) + if verbose: + tqdm.write(f'Dual graph: {dual_edges.shape[0]} edges') + + ## solve mincut problem + ### construct main graph + g = igraph.Graph() + g.add_vertices(faces.shape[0]) + g.add_edges(dual_edges.cpu().numpy()) + g.es['weight'] = dual_edges_weights.cpu().numpy() + + ### source and target + g.add_vertex('s') + g.add_vertex('t') + + ### connect invisible faces to source + g.add_edges([(f, 's') for f in inner_face_indices], attributes={'weight': torch.ones(inner_face_indices.shape[0], dtype=torch.float32).cpu().numpy()}) + + ### connect outer faces to target + g.add_edges([(f, 't') for f in outer_face_indices], attributes={'weight': torch.ones(outer_face_indices.shape[0], dtype=torch.float32).cpu().numpy()}) + + ### solve mincut + cut = g.mincut('s', 't', (np.array(g.es['weight']) * 1000).tolist()) + remove_face_indices = torch.tensor([v for v in cut.partition[0] if v < faces.shape[0]], dtype=torch.long, device=faces.device) + if verbose: + tqdm.write(f'Mincut solved, start checking the cut') + + ### check if the cut is valid with each connected component + to_remove_cc = utils3d.torch.compute_connected_components(faces[remove_face_indices]) + if debug: + tqdm.write(f'Number of connected components of the cut: {len(to_remove_cc)}') + valid_remove_cc = [] + cutting_edges = [] + for cc in to_remove_cc: + #### check if the connected component has low visibility + visblity_median = visblity[remove_face_indices[cc]].median() + if debug: + tqdm.write(f'visblity_median: {visblity_median}') + if visblity_median > 0.25: + continue + + #### check if the cuting loop is small enough + cc_edge_indices, cc_edges_degree = torch.unique(face2edge[remove_face_indices[cc]], return_counts=True) + cc_boundary_edge_indices = cc_edge_indices[cc_edges_degree == 1] + cc_new_boundary_edge_indices = cc_boundary_edge_indices[~torch.isin(cc_boundary_edge_indices, boundary_edge_indices)] + if len(cc_new_boundary_edge_indices) > 0: + cc_new_boundary_edge_cc = utils3d.torch.compute_edge_connected_components(edges[cc_new_boundary_edge_indices]) + cc_new_boundary_edges_cc_center = [verts[edges[cc_new_boundary_edge_indices[edge_cc]]].mean(dim=1).mean(dim=0) for edge_cc in cc_new_boundary_edge_cc] + cc_new_boundary_edges_cc_area = [] + for i, edge_cc in enumerate(cc_new_boundary_edge_cc): + _e1 = verts[edges[cc_new_boundary_edge_indices[edge_cc]][:, 0]] - cc_new_boundary_edges_cc_center[i] + _e2 = verts[edges[cc_new_boundary_edge_indices[edge_cc]][:, 1]] - cc_new_boundary_edges_cc_center[i] + cc_new_boundary_edges_cc_area.append(torch.norm(torch.cross(_e1, _e2, dim=-1), dim=1).sum() * 0.5) + if debug: + cutting_edges.append(cc_new_boundary_edge_indices) + tqdm.write(f'Area of the cutting loop: {cc_new_boundary_edges_cc_area}') + if any([l > max_hole_size for l in cc_new_boundary_edges_cc_area]): + continue + + valid_remove_cc.append(cc) + + if debug: + face_v = verts[faces].mean(dim=1).cpu().numpy() + vis_dual_edges = dual_edges.cpu().numpy() + vis_colors = np.zeros((faces.shape[0], 3), dtype=np.uint8) + vis_colors[inner_face_indices.cpu().numpy()] = [0, 0, 255] + vis_colors[outer_face_indices.cpu().numpy()] = [0, 255, 0] + vis_colors[remove_face_indices.cpu().numpy()] = [255, 0, 255] + if len(valid_remove_cc) > 0: + vis_colors[remove_face_indices[torch.cat(valid_remove_cc)].cpu().numpy()] = [255, 0, 0] + utils3d.io.write_ply('dbg_dual.ply', face_v, edges=vis_dual_edges, vertex_colors=vis_colors) + + vis_verts = verts.cpu().numpy() + vis_edges = edges[torch.cat(cutting_edges)].cpu().numpy() + utils3d.io.write_ply('dbg_cut.ply', vis_verts, edges=vis_edges) + + + if len(valid_remove_cc) > 0: + remove_face_indices = remove_face_indices[torch.cat(valid_remove_cc)] + mask = torch.ones(faces.shape[0], dtype=torch.bool, device=faces.device) + mask[remove_face_indices] = 0 + faces = faces[mask] + faces, verts = utils3d.torch.remove_unreferenced_vertices(faces, verts) + if verbose: + tqdm.write(f'Removed {(~mask).sum()} faces by mincut') + else: + if verbose: + tqdm.write(f'Removed 0 faces by mincut') + + mesh = _meshfix.PyTMesh() + mesh.load_array(verts.cpu().numpy(), faces.cpu().numpy()) + mesh.fill_small_boundaries(nbe=max_hole_nbe, refine=True) + verts, faces = mesh.return_arrays() + verts, faces = torch.tensor(verts, device='cuda', dtype=torch.float32), torch.tensor(faces, device='cuda', dtype=torch.int32) + + return verts, faces + + +def postprocess_mesh( + vertices: np.array, + faces: np.array, + simplify: bool = True, + simplify_ratio: float = 0.9, + fill_holes: bool = True, + fill_holes_max_hole_size: float = 0.04, + fill_holes_max_hole_nbe: int = 32, + fill_holes_resolution: int = 1024, + fill_holes_num_views: int = 1000, + debug: bool = False, + verbose: bool = False, +): + """ + Postprocess a mesh by simplifying, removing invisible faces, and removing isolated pieces. + + Args: + vertices (np.array): Vertices of the mesh. Shape (V, 3). + faces (np.array): Faces of the mesh. Shape (F, 3). + simplify (bool): Whether to simplify the mesh, using quadric edge collapse. + simplify_ratio (float): Ratio of faces to keep after simplification. + fill_holes (bool): Whether to fill holes in the mesh. + fill_holes_max_hole_size (float): Maximum area of a hole to fill. + fill_holes_max_hole_nbe (int): Maximum number of boundary edges of a hole to fill. + fill_holes_resolution (int): Resolution of the rasterization. + fill_holes_num_views (int): Number of views to rasterize the mesh. + verbose (bool): Whether to print progress. + """ + + if verbose: + tqdm.write(f'Before postprocess: {vertices.shape[0]} vertices, {faces.shape[0]} faces') + + # Simplify + if simplify and simplify_ratio > 0: + mesh = pv.PolyData(vertices, np.concatenate([np.full((faces.shape[0], 1), 3), faces], axis=1)) + mesh = mesh.decimate(simplify_ratio, progress_bar=verbose) + vertices, faces = mesh.points, mesh.faces.reshape(-1, 4)[:, 1:] + if verbose: + tqdm.write(f'After decimate: {vertices.shape[0]} vertices, {faces.shape[0]} faces') + + # Remove invisible faces + if fill_holes: + vertices, faces = torch.tensor(vertices).cuda(), torch.tensor(faces.astype(np.int32)).cuda() + vertices, faces = _fill_holes( + vertices, faces, + max_hole_size=fill_holes_max_hole_size, + max_hole_nbe=fill_holes_max_hole_nbe, + resolution=fill_holes_resolution, + num_views=fill_holes_num_views, + debug=debug, + verbose=verbose, + ) + vertices, faces = vertices.cpu().numpy(), faces.cpu().numpy() + if verbose: + tqdm.write(f'After remove invisible faces: {vertices.shape[0]} vertices, {faces.shape[0]} faces') + + return vertices, faces + + +def parametrize_mesh(vertices: np.array, faces: np.array): + """ + Parametrize a mesh to a texture space, using xatlas. + + Args: + vertices (np.array): Vertices of the mesh. Shape (V, 3). + faces (np.array): Faces of the mesh. Shape (F, 3). + """ + + vmapping, indices, uvs = xatlas.parametrize(vertices, faces) + + vertices = vertices[vmapping] + faces = indices + + return vertices, faces, uvs + + +def bake_texture( + vertices: np.array, + faces: np.array, + uvs: np.array, + observations: List[np.array], + masks: List[np.array], + extrinsics: List[np.array], + intrinsics: List[np.array], + texture_size: int = 2048, + near: float = 0.1, + far: float = 10.0, + mode: Literal['fast', 'opt'] = 'opt', + lambda_tv: float = 1e-2, + verbose: bool = False, +): + """ + Bake texture to a mesh from multiple observations. + + Args: + vertices (np.array): Vertices of the mesh. Shape (V, 3). + faces (np.array): Faces of the mesh. Shape (F, 3). + uvs (np.array): UV coordinates of the mesh. Shape (V, 2). + observations (List[np.array]): List of observations. Each observation is a 2D image. Shape (H, W, 3). + masks (List[np.array]): List of masks. Each mask is a 2D image. Shape (H, W). + extrinsics (List[np.array]): List of extrinsics. Shape (4, 4). + intrinsics (List[np.array]): List of intrinsics. Shape (3, 3). + texture_size (int): Size of the texture. + near (float): Near plane of the camera. + far (float): Far plane of the camera. + mode (Literal['fast', 'opt']): Mode of texture baking. + lambda_tv (float): Weight of total variation loss in optimization. + verbose (bool): Whether to print progress. + """ + vertices = torch.tensor(vertices).cuda() + faces = torch.tensor(faces.astype(np.int32)).cuda() + uvs = torch.tensor(uvs).cuda() + observations = [torch.tensor(obs / 255.0).float().cuda() for obs in observations] + masks = [torch.tensor(m>0).bool().cuda() for m in masks] + views = [utils3d.torch.extrinsics_to_view(torch.tensor(extr).cuda()) for extr in extrinsics] + projections = [utils3d.torch.intrinsics_to_perspective(torch.tensor(intr).cuda(), near, far) for intr in intrinsics] + + if mode == 'fast': + texture = torch.zeros((texture_size * texture_size, 3), dtype=torch.float32).cuda() + texture_weights = torch.zeros((texture_size * texture_size), dtype=torch.float32).cuda() + rastctx = utils3d.torch.RastContext(backend='cuda') + for observation, view, projection in tqdm(zip(observations, views, projections), total=len(observations), disable=not verbose, desc='Texture baking (fast)'): + with torch.no_grad(): + rast = utils3d.torch.rasterize_triangle_faces( + rastctx, vertices[None], faces, observation.shape[1], observation.shape[0], uv=uvs[None], view=view, projection=projection + ) + uv_map = rast['uv'][0].detach().flip(0) + mask = rast['mask'][0].detach().bool() & masks[0] + + # nearest neighbor interpolation + uv_map = (uv_map * texture_size).floor().long() + obs = observation[mask] + uv_map = uv_map[mask] + idx = uv_map[:, 0] + (texture_size - uv_map[:, 1] - 1) * texture_size + texture = texture.scatter_add(0, idx.view(-1, 1).expand(-1, 3), obs) + texture_weights = texture_weights.scatter_add(0, idx, torch.ones((obs.shape[0]), dtype=torch.float32, device=texture.device)) + + mask = texture_weights > 0 + texture[mask] /= texture_weights[mask][:, None] + texture = np.clip(texture.reshape(texture_size, texture_size, 3).cpu().numpy() * 255, 0, 255).astype(np.uint8) + + # inpaint + mask = (texture_weights == 0).cpu().numpy().astype(np.uint8).reshape(texture_size, texture_size) + texture = cv2.inpaint(texture, mask, 3, cv2.INPAINT_TELEA) + + elif mode == 'opt': + rastctx = utils3d.torch.RastContext(backend='cuda') + observations = [observations.flip(0) for observations in observations] + masks = [m.flip(0) for m in masks] + _uv = [] + _uv_dr = [] + for observation, view, projection in tqdm(zip(observations, views, projections), total=len(views), disable=not verbose, desc='Texture baking (opt): UV'): + with torch.no_grad(): + rast = utils3d.torch.rasterize_triangle_faces( + rastctx, vertices[None], faces, observation.shape[1], observation.shape[0], uv=uvs[None], view=view, projection=projection + ) + _uv.append(rast['uv'].detach()) + _uv_dr.append(rast['uv_dr'].detach()) + + texture = torch.nn.Parameter(torch.zeros((1, texture_size, texture_size, 3), dtype=torch.float32).cuda()) + optimizer = torch.optim.Adam([texture], betas=(0.5, 0.9), lr=1e-2) + + def exp_anealing(optimizer, step, total_steps, start_lr, end_lr): + return start_lr * (end_lr / start_lr) ** (step / total_steps) + + def cosine_anealing(optimizer, step, total_steps, start_lr, end_lr): + return end_lr + 0.5 * (start_lr - end_lr) * (1 + np.cos(np.pi * step / total_steps)) + + def tv_loss(texture): + return torch.nn.functional.l1_loss(texture[:, :-1, :, :], texture[:, 1:, :, :]) + \ + torch.nn.functional.l1_loss(texture[:, :, :-1, :], texture[:, :, 1:, :]) + + total_steps = 2500 + with tqdm(total=total_steps, disable=not verbose, desc='Texture baking (opt): optimizing') as pbar: + for step in range(total_steps): + optimizer.zero_grad() + selected = np.random.randint(0, len(views)) + uv, uv_dr, observation, mask = _uv[selected], _uv_dr[selected], observations[selected], masks[selected] + render = dr.texture(texture, uv, uv_dr)[0] + loss = torch.nn.functional.l1_loss(render[mask], observation[mask]) + if lambda_tv > 0: + loss += lambda_tv * tv_loss(texture) + loss.backward() + optimizer.step() + # annealing + optimizer.param_groups[0]['lr'] = cosine_anealing(optimizer, step, total_steps, 1e-2, 1e-5) + pbar.set_postfix({'loss': loss.item()}) + pbar.update() + texture = np.clip(texture[0].flip(0).detach().cpu().numpy() * 255, 0, 255).astype(np.uint8) + mask = 1 - utils3d.torch.rasterize_triangle_faces( + rastctx, (uvs * 2 - 1)[None], faces, texture_size, texture_size + )['mask'][0].detach().cpu().numpy().astype(np.uint8) + texture = cv2.inpaint(texture, mask, 3, cv2.INPAINT_TELEA) + else: + raise ValueError(f'Unknown mode: {mode}') + + return texture + + +def to_glb( + app_rep: Union[Strivec, Gaussian], + mesh: MeshExtractResult, + simplify: float = 0.95, + fill_holes: bool = True, + fill_holes_max_size: float = 0.04, + texture_size: int = 1024, + debug: bool = False, + verbose: bool = True, +) -> trimesh.Trimesh: + """ + Convert a generated asset to a glb file. + + Args: + app_rep (Union[Strivec, Gaussian]): Appearance representation. + mesh (MeshExtractResult): Extracted mesh. + simplify (float): Ratio of faces to remove in simplification. + fill_holes (bool): Whether to fill holes in the mesh. + fill_holes_max_size (float): Maximum area of a hole to fill. + texture_size (int): Size of the texture. + debug (bool): Whether to print debug information. + verbose (bool): Whether to print progress. + """ + vertices = mesh.vertices.cpu().numpy() + faces = mesh.faces.cpu().numpy() + + # mesh postprocess + vertices, faces = postprocess_mesh( + vertices, faces, + simplify=simplify > 0, + simplify_ratio=simplify, + fill_holes=fill_holes, + fill_holes_max_hole_size=fill_holes_max_size, + fill_holes_max_hole_nbe=int(250 * np.sqrt(1-simplify)), + fill_holes_resolution=1024, + fill_holes_num_views=1000, + debug=debug, + verbose=verbose, + ) + + # parametrize mesh + vertices, faces, uvs = parametrize_mesh(vertices, faces) + + # bake texture + observations, extrinsics, intrinsics = render_multiview(app_rep, resolution=1024, nviews=100) + masks = [np.any(observation > 0, axis=-1) for observation in observations] + extrinsics = [extrinsics[i].cpu().numpy() for i in range(len(extrinsics))] + intrinsics = [intrinsics[i].cpu().numpy() for i in range(len(intrinsics))] + texture = bake_texture( + vertices, faces, uvs, + observations, masks, extrinsics, intrinsics, + texture_size=texture_size, mode='opt', + lambda_tv=0.01, + verbose=verbose + ) + texture = Image.fromarray(texture) + + # rotate mesh (from z-up to y-up) + vertices = vertices @ np.array([[1, 0, 0], [0, 0, -1], [0, 1, 0]]) + material = trimesh.visual.material.PBRMaterial( + roughnessFactor=1.0, + baseColorTexture=texture, + baseColorFactor=np.array([255, 255, 255, 255], dtype=np.uint8) + ) + mesh = trimesh.Trimesh(vertices, faces, visual=trimesh.visual.TextureVisuals(uv=uvs, material=material)) + return mesh + + +def simplify_gs( + gs: Gaussian, + simplify: float = 0.95, + verbose: bool = True, +): + """ + Simplify 3D Gaussians + NOTE: this function is not used in the current implementation for the unsatisfactory performance. + + Args: + gs (Gaussian): 3D Gaussian. + simplify (float): Ratio of Gaussians to remove in simplification. + """ + if simplify <= 0: + return gs + + # simplify + observations, extrinsics, intrinsics = render_multiview(gs, resolution=1024, nviews=100) + observations = [torch.tensor(obs / 255.0).float().cuda().permute(2, 0, 1) for obs in observations] + + # Following https://arxiv.org/pdf/2411.06019 + renderer = GaussianRenderer({ + "resolution": 1024, + "near": 0.8, + "far": 1.6, + "ssaa": 1, + "bg_color": (0,0,0), + }) + new_gs = Gaussian(**gs.init_params) + new_gs._features_dc = gs._features_dc.clone() + new_gs._features_rest = gs._features_rest.clone() if gs._features_rest is not None else None + new_gs._opacity = torch.nn.Parameter(gs._opacity.clone()) + new_gs._rotation = torch.nn.Parameter(gs._rotation.clone()) + new_gs._scaling = torch.nn.Parameter(gs._scaling.clone()) + new_gs._xyz = torch.nn.Parameter(gs._xyz.clone()) + + start_lr = [1e-4, 1e-3, 5e-3, 0.025] + end_lr = [1e-6, 1e-5, 5e-5, 0.00025] + optimizer = torch.optim.Adam([ + {"params": new_gs._xyz, "lr": start_lr[0]}, + {"params": new_gs._rotation, "lr": start_lr[1]}, + {"params": new_gs._scaling, "lr": start_lr[2]}, + {"params": new_gs._opacity, "lr": start_lr[3]}, + ], lr=start_lr[0]) + + def exp_anealing(optimizer, step, total_steps, start_lr, end_lr): + return start_lr * (end_lr / start_lr) ** (step / total_steps) + + def cosine_anealing(optimizer, step, total_steps, start_lr, end_lr): + return end_lr + 0.5 * (start_lr - end_lr) * (1 + np.cos(np.pi * step / total_steps)) + + _zeta = new_gs.get_opacity.clone().detach().squeeze() + _lambda = torch.zeros_like(_zeta) + _delta = 1e-7 + _interval = 10 + num_target = int((1 - simplify) * _zeta.shape[0]) + + with tqdm(total=2500, disable=not verbose, desc='Simplifying Gaussian') as pbar: + for i in range(2500): + # prune + if i % 100 == 0: + mask = new_gs.get_opacity.squeeze() > 0.05 + mask = torch.nonzero(mask).squeeze() + new_gs._xyz = torch.nn.Parameter(new_gs._xyz[mask]) + new_gs._rotation = torch.nn.Parameter(new_gs._rotation[mask]) + new_gs._scaling = torch.nn.Parameter(new_gs._scaling[mask]) + new_gs._opacity = torch.nn.Parameter(new_gs._opacity[mask]) + new_gs._features_dc = new_gs._features_dc[mask] + new_gs._features_rest = new_gs._features_rest[mask] if new_gs._features_rest is not None else None + _zeta = _zeta[mask] + _lambda = _lambda[mask] + # update optimizer state + for param_group, new_param in zip(optimizer.param_groups, [new_gs._xyz, new_gs._rotation, new_gs._scaling, new_gs._opacity]): + stored_state = optimizer.state[param_group['params'][0]] + if 'exp_avg' in stored_state: + stored_state['exp_avg'] = stored_state['exp_avg'][mask] + stored_state['exp_avg_sq'] = stored_state['exp_avg_sq'][mask] + del optimizer.state[param_group['params'][0]] + param_group['params'][0] = new_param + optimizer.state[param_group['params'][0]] = stored_state + + opacity = new_gs.get_opacity.squeeze() + + # sparisfy + if i % _interval == 0: + _zeta = _lambda + opacity.detach() + if opacity.shape[0] > num_target: + index = _zeta.topk(num_target)[1] + _m = torch.ones_like(_zeta, dtype=torch.bool) + _m[index] = 0 + _zeta[_m] = 0 + _lambda = _lambda + opacity.detach() - _zeta + + # sample a random view + view_idx = np.random.randint(len(observations)) + observation = observations[view_idx] + extrinsic = extrinsics[view_idx] + intrinsic = intrinsics[view_idx] + + color = renderer.render(new_gs, extrinsic, intrinsic)['color'] + rgb_loss = torch.nn.functional.l1_loss(color, observation) + loss = rgb_loss + \ + _delta * torch.sum(torch.pow(_lambda + opacity - _zeta, 2)) + + optimizer.zero_grad() + loss.backward() + optimizer.step() + + # update lr + for j in range(len(optimizer.param_groups)): + optimizer.param_groups[j]['lr'] = cosine_anealing(optimizer, i, 2500, start_lr[j], end_lr[j]) + + pbar.set_postfix({'loss': rgb_loss.item(), 'num': opacity.shape[0], 'lambda': _lambda.mean().item()}) + pbar.update() + + new_gs._xyz = new_gs._xyz.data + new_gs._rotation = new_gs._rotation.data + new_gs._scaling = new_gs._scaling.data + new_gs._opacity = new_gs._opacity.data + + return new_gs diff --git a/thirdparty/TRELLIS/trellis/utils/random_utils.py b/thirdparty/TRELLIS/trellis/utils/random_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..5b668c277b51f4930991912a80573adc79364028 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/utils/random_utils.py @@ -0,0 +1,30 @@ +import numpy as np + +PRIMES = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53] + +def radical_inverse(base, n): + val = 0 + inv_base = 1.0 / base + inv_base_n = inv_base + while n > 0: + digit = n % base + val += digit * inv_base_n + n //= base + inv_base_n *= inv_base + return val + +def halton_sequence(dim, n): + return [radical_inverse(PRIMES[dim], n) for dim in range(dim)] + +def hammersley_sequence(dim, n, num_samples): + return [n / num_samples] + halton_sequence(dim - 1, n) + +def sphere_hammersley_sequence(n, num_samples, offset=(0, 0), remap=False): + u, v = hammersley_sequence(2, n, num_samples) + u += offset[0] / num_samples + v += offset[1] + if remap: + u = 2 * u if u < 0.25 else 2 / 3 * u + 1 / 3 + theta = np.arccos(1 - 2 * u) - np.pi / 2 + phi = v * 2 * np.pi + return [phi, theta] \ No newline at end of file diff --git a/thirdparty/TRELLIS/trellis/utils/render_utils.py b/thirdparty/TRELLIS/trellis/utils/render_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..8187c84f305d51540e88ae5b634a484a74c16e95 --- /dev/null +++ b/thirdparty/TRELLIS/trellis/utils/render_utils.py @@ -0,0 +1,116 @@ +import torch +import numpy as np +from tqdm import tqdm +import utils3d +from PIL import Image + +from ..renderers import OctreeRenderer, GaussianRenderer, MeshRenderer +from ..representations import Octree, Gaussian, MeshExtractResult +from ..modules import sparse as sp +from .random_utils import sphere_hammersley_sequence + + +def yaw_pitch_r_fov_to_extrinsics_intrinsics(yaws, pitchs, rs, fovs): + is_list = isinstance(yaws, list) + if not is_list: + yaws = [yaws] + pitchs = [pitchs] + if not isinstance(rs, list): + rs = [rs] * len(yaws) + if not isinstance(fovs, list): + fovs = [fovs] * len(yaws) + extrinsics = [] + intrinsics = [] + for yaw, pitch, r, fov in zip(yaws, pitchs, rs, fovs): + fov = torch.deg2rad(torch.tensor(float(fov))).cuda() + yaw = torch.tensor(float(yaw)).cuda() + pitch = torch.tensor(float(pitch)).cuda() + orig = torch.tensor([ + torch.sin(yaw) * torch.cos(pitch), + torch.cos(yaw) * torch.cos(pitch), + torch.sin(pitch), + ]).cuda() * r + extr = utils3d.torch.extrinsics_look_at(orig, torch.tensor([0, 0, 0]).float().cuda(), torch.tensor([0, 0, 1]).float().cuda()) + intr = utils3d.torch.intrinsics_from_fov_xy(fov, fov) + extrinsics.append(extr) + intrinsics.append(intr) + if not is_list: + extrinsics = extrinsics[0] + intrinsics = intrinsics[0] + return extrinsics, intrinsics + + +def render_frames(sample, extrinsics, intrinsics, options={}, colors_overwrite=None, verbose=True, **kwargs): + if isinstance(sample, Octree): + renderer = OctreeRenderer() + renderer.rendering_options.resolution = options.get('resolution', 512) + renderer.rendering_options.near = options.get('near', 0.8) + renderer.rendering_options.far = options.get('far', 1.6) + renderer.rendering_options.bg_color = options.get('bg_color', (0, 0, 0)) + renderer.rendering_options.ssaa = options.get('ssaa', 4) + renderer.pipe.primitive = sample.primitive + elif isinstance(sample, Gaussian): + renderer = GaussianRenderer() + renderer.rendering_options.resolution = options.get('resolution', 512) + renderer.rendering_options.near = options.get('near', 0.8) + renderer.rendering_options.far = options.get('far', 1.6) + renderer.rendering_options.bg_color = options.get('bg_color', (0, 0, 0)) + renderer.rendering_options.ssaa = options.get('ssaa', 1) + renderer.pipe.kernel_size = kwargs.get('kernel_size', 0.1) + renderer.pipe.use_mip_gaussian = True + elif isinstance(sample, MeshExtractResult): + renderer = MeshRenderer() + renderer.rendering_options.resolution = options.get('resolution', 512) + renderer.rendering_options.near = options.get('near', 1) + renderer.rendering_options.far = options.get('far', 100) + renderer.rendering_options.ssaa = options.get('ssaa', 4) + else: + raise ValueError(f'Unsupported sample type: {type(sample)}') + + rets = {} + for j, (extr, intr) in tqdm(enumerate(zip(extrinsics, intrinsics)), desc='Rendering', disable=not verbose): + if not isinstance(sample, MeshExtractResult): + res = renderer.render(sample, extr, intr, colors_overwrite=colors_overwrite) + if 'color' not in rets: rets['color'] = [] + if 'depth' not in rets: rets['depth'] = [] + rets['color'].append(np.clip(res['color'].detach().cpu().numpy().transpose(1, 2, 0) * 255, 0, 255).astype(np.uint8)) + if 'percent_depth' in res: + rets['depth'].append(res['percent_depth'].detach().cpu().numpy()) + elif 'depth' in res: + rets['depth'].append(res['depth'].detach().cpu().numpy()) + else: + rets['depth'].append(None) + else: + res = renderer.render(sample, extr, intr) + if 'normal' not in rets: rets['normal'] = [] + rets['normal'].append(np.clip(res['normal'].detach().cpu().numpy().transpose(1, 2, 0) * 255, 0, 255).astype(np.uint8)) + return rets + + +def render_video(sample, resolution=512, bg_color=(0, 0, 0), num_frames=300, r=2, fov=40, **kwargs): + yaws = torch.linspace(0, 2 * 3.1415, num_frames) + pitch = 0.25 + 0.5 * torch.sin(torch.linspace(0, 2 * 3.1415, num_frames)) + yaws = yaws.tolist() + pitch = pitch.tolist() + extrinsics, intrinsics = yaw_pitch_r_fov_to_extrinsics_intrinsics(yaws, pitch, r, fov) + return render_frames(sample, extrinsics, intrinsics, {'resolution': resolution, 'bg_color': bg_color}, **kwargs) + + +def render_multiview(sample, resolution=512, nviews=30): + r = 2 + fov = 40 + cams = [sphere_hammersley_sequence(i, nviews) for i in range(nviews)] + yaws = [cam[0] for cam in cams] + pitchs = [cam[1] for cam in cams] + extrinsics, intrinsics = yaw_pitch_r_fov_to_extrinsics_intrinsics(yaws, pitchs, r, fov) + res = render_frames(sample, extrinsics, intrinsics, {'resolution': resolution, 'bg_color': (0, 0, 0)}) + return res['color'], extrinsics, intrinsics + + +def render_snapshot(samples, resolution=512, bg_color=(0, 0, 0), offset=(-16 / 180 * np.pi, 20 / 180 * np.pi), r=10, fov=8, **kwargs): + yaw = [0, np.pi/2, np.pi, 3*np.pi/2] + yaw_offset = offset[0] + yaw = [y + yaw_offset for y in yaw] + pitch = [offset[1] for _ in range(4)] + extrinsics, intrinsics = yaw_pitch_r_fov_to_extrinsics_intrinsics(yaw, pitch, r, fov) + return render_frames(samples, extrinsics, intrinsics, {'resolution': resolution, 'bg_color': bg_color}, **kwargs)