diff --git a/.gitattributes b/.gitattributes index bed0738c7eeb449bca98b5d2f33c89a1ee56349a..b200aad25a867d24624d308f383db6b87d0628b5 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,60 +1,4 @@ -*.7z filter=lfs diff=lfs merge=lfs -text -*.arrow filter=lfs diff=lfs merge=lfs -text -*.avro filter=lfs diff=lfs merge=lfs -text -*.bin filter=lfs diff=lfs merge=lfs -text -*.bz2 filter=lfs diff=lfs merge=lfs -text -*.ckpt filter=lfs diff=lfs merge=lfs -text -*.ftz filter=lfs diff=lfs merge=lfs -text -*.gz filter=lfs diff=lfs merge=lfs -text -*.h5 filter=lfs diff=lfs merge=lfs -text -*.joblib filter=lfs diff=lfs merge=lfs -text -*.lfs.* filter=lfs diff=lfs merge=lfs -text -*.lz4 filter=lfs diff=lfs merge=lfs -text -*.mds filter=lfs diff=lfs merge=lfs -text -*.mlmodel filter=lfs diff=lfs merge=lfs -text -*.model filter=lfs diff=lfs merge=lfs -text -*.msgpack filter=lfs diff=lfs merge=lfs -text -*.npy filter=lfs diff=lfs merge=lfs -text -*.npz filter=lfs diff=lfs merge=lfs -text -*.onnx filter=lfs diff=lfs merge=lfs -text -*.ot filter=lfs diff=lfs merge=lfs -text -*.parquet filter=lfs diff=lfs merge=lfs -text -*.pb filter=lfs diff=lfs merge=lfs -text -*.pickle filter=lfs diff=lfs merge=lfs -text -*.pkl filter=lfs diff=lfs merge=lfs -text -*.pt filter=lfs diff=lfs merge=lfs -text -*.pth filter=lfs diff=lfs merge=lfs -text -*.rar filter=lfs diff=lfs merge=lfs -text -*.safetensors filter=lfs diff=lfs merge=lfs -text -saved_model/**/* filter=lfs diff=lfs merge=lfs -text -*.tar.* filter=lfs diff=lfs merge=lfs -text +* text=auto eol=lf +*.jsonl filter=lfs diff=lfs merge=lfs -text *.tar filter=lfs diff=lfs merge=lfs -text -*.tflite filter=lfs diff=lfs merge=lfs -text -*.tgz filter=lfs diff=lfs merge=lfs -text -*.wasm filter=lfs diff=lfs merge=lfs -text -*.xz filter=lfs diff=lfs merge=lfs -text -*.zip filter=lfs diff=lfs merge=lfs -text -*.zst filter=lfs diff=lfs merge=lfs -text -*tfevents* filter=lfs diff=lfs merge=lfs -text -# Audio files - uncompressed -*.pcm filter=lfs diff=lfs merge=lfs -text -*.sam filter=lfs diff=lfs merge=lfs -text -*.raw filter=lfs diff=lfs merge=lfs -text -# Audio files - compressed -*.aac filter=lfs diff=lfs merge=lfs -text -*.flac filter=lfs diff=lfs merge=lfs -text -*.mp3 filter=lfs diff=lfs merge=lfs -text -*.ogg filter=lfs diff=lfs merge=lfs -text -*.wav filter=lfs diff=lfs merge=lfs -text -# Image files - uncompressed -*.bmp filter=lfs diff=lfs merge=lfs -text -*.gif filter=lfs diff=lfs merge=lfs -text -*.png filter=lfs diff=lfs merge=lfs -text -*.tiff filter=lfs diff=lfs merge=lfs -text -# Image files - compressed -*.jpg filter=lfs diff=lfs merge=lfs -text -*.jpeg filter=lfs diff=lfs merge=lfs -text -*.webp filter=lfs diff=lfs merge=lfs -text -# Video files - compressed -*.mp4 filter=lfs diff=lfs merge=lfs -text -*.webm filter=lfs diff=lfs merge=lfs -text +*.pdf -text diff --git a/DATA_LICENSE.md b/DATA_LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..65ad569af80b64568ec9feb81bf4714e72753a88 --- /dev/null +++ b/DATA_LICENSE.md @@ -0,0 +1,19 @@ +# Data sources and terms + +MindView combines original task annotations with RGB images and depth maps from ScanNet, ScanNet++, and ARKitScenes. Source data retains its original copyright and applicable terms. The MindView code license does not relicense these assets. + +The publisher has confirmed additional permission for this public redistribution. This hosting permission does not assign a blanket open-data license to the mixed-source package or replace the original source notices. + +| Source | Original terms and notices | +|---|---| +| ScanNet | [Terms of Use](third_party/ScanNet/TERMS_OF_USE.pdf): noncommercial research and education; the standard terms require recipients to agree before sharing. | +| ScanNet++ | [Terms of Use](third_party/ScanNetpp/TERMS_OF_USE.pdf): noncommercial research and education; the standard terms require recipients to agree and sign before sharing. | +| ARKitScenes | [Apple license](third_party/ARKitScenes/LICENSE): retain the applicable notices and comply with its use and redistribution conditions. | + +Copies of the original notices accompany this release. Their source URLs and byte fingerprints are recorded in [third_party/SOURCES.json](third_party/SOURCES.json). Additional publisher-held permissions concern this hosted release; downstream uses must respect the terms applicable to those uses. + +MindView-authored instructions, sample selection, and experiment mappings are distinct from the source imagery. No blanket license over third-party data is implied. For permissions beyond those explicitly granted by the applicable terms, contact the release authors. + +Please cite MindView and the original source datasets when using this resource. Source projects: [ScanNet](https://www.scan-net.org/), [ScanNet++](https://scannetpp.mlsg.cit.tum.de/scannetpp/), and [ARKitScenes](https://github.com/apple/ARKitScenes). + +Contact: Yihao Liu (`liuyihao@pjlab.org.cn`) and Jiwen Lu (`lujiwen@tsinghua.edu.cn`). diff --git a/README.md b/README.md index 0cb51054aad6ca9b479356fcaa6947586b51ba27..53bfee92c988d75bad44bbab10d5c8d80a255d82 100644 --- a/README.md +++ b/README.md @@ -1,46 +1,74 @@ --- +license: other +license_name: mindview-source-dependent-terms +license_link: https://huggingface.co/datasets/wangyanbo/MindView-Train/blob/main/DATA_LICENSE.md language: - en tags: - mindview -- training-data - multi-view -- spatial-intelligence -- image-to-image +- spatial-reasoning +- image-generation +- supervised-fine-tuning +size_categories: +- 10K str: + if not isinstance(value, str) or not value or "\\" in value or any(ord(char) < 32 or ord(char) == 127 for char in value): + raise VerificationError(f"Invalid {label}: {value!r}") + parts = value.split("/") + if value.startswith("/") or any(p in {"", ".", ".."} for p in parts): + raise VerificationError(f"Unsafe {label}: {value!r}") + if ":" in parts[0] or str(PurePosixPath(value)) != value: + raise VerificationError(f"Noncanonical {label}: {value!r}") + return value + + +def digest_value(value: object, label: str) -> str: + if not isinstance(value, str) or SHA.fullmatch(value) is None: + raise VerificationError(f"Invalid SHA256 for {label}") + return value + + +def size_value(value: object, label: str) -> int: + if type(value) is not int or value < 0: + raise VerificationError(f"Invalid byte size for {label}") + return value + + +def check_ancestors(path: Path, *, missing_ok: bool = False) -> None: + """Reject symlinks and non-directories in every existing parent component.""" + absolute = path.absolute() + current = Path(absolute.anchor) + for part in absolute.parts[1:]: + current = current / part + try: + status = current.lstat() + except FileNotFoundError: + if missing_ok: + return + raise VerificationError(f"Missing directory: {current}") from None + if stat.S_ISLNK(status.st_mode) or not stat.S_ISDIR(status.st_mode): + raise VerificationError(f"Expected a real directory, found unsafe component: {current}") + + +def input_file(repo: Path, name: str) -> Path: + path = repo / relative(name, "repository path") + check_ancestors(path.parent) + try: + mode = path.lstat().st_mode + except FileNotFoundError: + raise VerificationError(f"Missing package file: {name}") from None + if not stat.S_ISREG(mode): + raise VerificationError(f"Package file is not a regular file: {name}") + return path + + +def open_regular(path: Path): + flags = os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) + fd = os.open(path, flags) + if not stat.S_ISREG(os.fstat(fd).st_mode): + os.close(fd) + raise VerificationError(f"Not a regular file: {path}") + return os.fdopen(fd, "rb") + + +def hash_stream(stream) -> tuple[str, int]: + digest = hashlib.sha256() + total = 0 + while True: + block = stream.read(CHUNK) + if not block: + return digest.hexdigest(), total + digest.update(block) + total += len(block) + + +def file_hash(path: Path) -> tuple[str, int]: + with open_regular(path) as stream: + return hash_stream(stream) + + +def checksum_inventory(repo: Path) -> dict[str, str]: + checks = {} + inventory = input_file(repo, "SHA256SUMS") + with inventory.open("r", encoding="utf-8") as stream: + for number, line in enumerate(stream, 1): + line = line.rstrip("\n") + match = re.fullmatch(r"([0-9a-f]{64}) [ *](.+)", line) + if match is None: + raise VerificationError(f"Malformed SHA256SUMS line {number}") + expected, name = match.groups() + relative(name, "checksum path") + if name == "SHA256SUMS" or name in checks: + raise VerificationError(f"Duplicate/self-referential checksum path: {name}") + checks[name] = expected + if not checks: + raise VerificationError("Empty SHA256SUMS inventory") + for name, expected in checks.items(): + actual, _ = file_hash(input_file(repo, name)) + if actual != expected: + raise VerificationError(f"Checksum mismatch: {name}") + return checks + + +def read_manifest(repo: Path, checks: dict[str, str]): + index_name = "manifests/asset_archives.json" + assets_name = "manifests/assets.jsonl" + for name in (index_name, assets_name): + if name not in checks: + raise VerificationError(f"Missing checksum entry: {name}") + with input_file(repo, index_name).open("r", encoding="utf-8") as stream: + index = json.load(stream) + if not isinstance(index, dict) or not isinstance(index.get("archives"), list): + raise VerificationError("Archive index must contain an archives list") + archives = {} + members = {} + destinations = set() + for entry in index["archives"]: + if not isinstance(entry, dict): + raise VerificationError("Archive entry must be an object") + name = relative(entry.get("path"), "archive path") + if not name.startswith("assets/") or not name.endswith(".tar"): + raise VerificationError(f"Expected an assets/*.tar archive: {name}") + if name in archives: + raise VerificationError(f"Duplicate archive: {name}") + source = entry.get("dataset") + if not isinstance(source, str) or source not in SOURCES: + raise VerificationError(f"Unknown source dataset: {source!r}") + size_value(entry.get("bytes"), name) + digest_value(entry.get("sha256"), name) + if checks.get(name) != entry["sha256"]: + raise VerificationError(f"Archive hash absent/inconsistent in SHA256SUMS: {name}") + if input_file(repo, name).stat().st_size != entry["bytes"]: + raise VerificationError(f"Archive size mismatch: {name}") + archives[name] = entry + members[name] = {} + with input_file(repo, assets_name).open("r", encoding="utf-8") as stream: + for number, line in enumerate(stream, 1): + try: + row = json.loads(line) + except json.JSONDecodeError as exc: + raise VerificationError(f"Malformed assets.jsonl line {number}: {exc}") from None + if not isinstance(row, dict): + raise VerificationError(f"Asset row {number} is not an object") + shard = relative(row.get("shard"), "asset shard") + member = relative(row.get("member"), "TAR member") + source_path = relative(row.get("relative_path"), "asset source path") + if shard not in archives: + raise VerificationError(f"Asset points to an unlisted archive: {shard}") + if row.get("dataset") != archives[shard]["dataset"]: + raise VerificationError(f"Dataset mismatch for {shard}:{member}") + if member != source_path: + raise VerificationError(f"Member/source path mismatch: {shard}:{member}") + size_value(row.get("bytes"), member) + digest_value(row.get("sha256"), member) + destination = f"{row['dataset']}/{source_path}" + if member in members[shard] or destination in destinations: + raise VerificationError(f"Duplicate asset destination: {destination}") + destinations.add(destination) + members[shard][member] = row + ordered_destinations = sorted(destinations) + for first, second in zip(ordered_destinations, ordered_destinations[1:]): + if second.startswith(first + "/"): + raise VerificationError(f"Overlapping asset destinations: {first} and {second}") + if not destinations or not archives: + raise VerificationError("Empty asset/archive inventory") + for name, entries in members.items(): + if not entries: + raise VerificationError(f"Archive has no listed assets: {name}") + declared = archives[name].get("num_assets") + if declared is not None and declared != len(entries): + raise VerificationError(f"Archive member count mismatch: {name}") + declared_bytes = archives[name].get("uncompressed_bytes") + if declared_bytes is not None and declared_bytes != sum(r["bytes"] for r in entries.values()): + raise VerificationError(f"Archive uncompressed byte count mismatch: {name}") + return archives, members + + +def checked_members(repo: Path, name: str, expected: dict): + """Yield regular, listed members only; the caller must consume all members.""" + seen = set() + with open_regular(input_file(repo, name)) as stream: + with tarfile.open(fileobj=stream, mode="r:") as archive: + for member in archive: + relative(member.name, "TAR member") + if not member.isfile() or member.issparse(): + raise VerificationError(f"Non-regular/sparse TAR member: {name}:{member.name}") + if member.name in seen or member.name not in expected: + raise VerificationError(f"Duplicate/unlisted TAR member: {name}:{member.name}") + seen.add(member.name) + row = expected[member.name] + if member.size != row["bytes"]: + raise VerificationError(f"Member size mismatch: {name}:{member.name}") + payload = archive.extractfile(member) + if payload is None: + raise VerificationError(f"Cannot read TAR member: {name}:{member.name}") + with payload: + yield row, payload + if seen != set(expected): + missing = sorted(set(expected) - seen) + raise VerificationError(f"Missing TAR members in {name}: {missing[:3]}") + + +def verify_members(repo: Path, members: dict) -> None: + for name, entries in members.items(): + for row, payload in checked_members(repo, name, entries): + digest, length = hash_stream(payload) + if digest != row["sha256"] or length != row["bytes"]: + raise VerificationError(f"Member checksum mismatch: {name}:{row['member']}") + + +def output_file(output: Path, row: dict) -> Path: + path = output / row["dataset"] / row["relative_path"] + check_ancestors(path.parent, missing_ok=True) + try: + mode = path.lstat().st_mode + except FileNotFoundError: + return path + if not stat.S_ISREG(mode): + raise VerificationError(f"Existing output is not a regular file: {path}") + actual, length = file_hash(path) + if actual != row["sha256"] or length != row["bytes"]: + raise VerificationError(f"Refusing to overwrite a conflicting output: {path}") + return path + + +def extract(repo: Path, output: Path, members: dict) -> tuple[int, int]: + # Preflight every destination before any writes; identical files are reusable. + for entries in members.values(): + for row in entries.values(): + output_file(output, row) + extracted = reused = 0 + for name, entries in members.items(): + for row, payload in checked_members(repo, name, entries): + path = output_file(output, row) + if path.exists(): + reused += 1 + # Ensure the second archive traversal still consumes payload safely. + digest, length = hash_stream(payload) + if digest != row["sha256"] or length != row["bytes"]: + raise VerificationError(f"Archive changed after verification: {name}:{row['member']}") + continue + path.parent.mkdir(parents=True, exist_ok=True) + check_ancestors(path.parent) + descriptor, temporary = tempfile.mkstemp(prefix=".mindview-", dir=path.parent) + try: + digest = hashlib.sha256() + length = 0 + with os.fdopen(descriptor, "wb") as target: + while True: + block = payload.read(CHUNK) + if not block: + break + target.write(block) + digest.update(block) + length += len(block) + target.flush() + os.fsync(target.fileno()) + if digest.hexdigest() != row["sha256"] or length != row["bytes"]: + raise VerificationError(f"Archive changed after verification: {name}:{row['member']}") + os.chmod(temporary, 0o644) + # A hard-link install is atomic and refuses to replace an existing path. + try: + os.link(temporary, path, follow_symlinks=False) + except FileExistsError: + output_file(output, row) + reused += 1 + else: + extracted += 1 + finally: + Path(temporary).unlink(missing_ok=True) + return extracted, reused + + +def main(argv=None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--repo", type=Path, default=Path(__file__).resolve().parents[1], help="Complete downloaded dataset repository") + group = parser.add_mutually_exclusive_group(required=True) + group.add_argument("--verify-only", action="store_true", help="Verify all package files and TAR members; write no assets") + group.add_argument("--output", type=Path, help="Extract under OUTPUT//") + args = parser.parse_args(argv) + repo = Path(os.path.abspath(args.repo)) + check_ancestors(repo) + checks = checksum_inventory(repo) + archives, members = read_manifest(repo, checks) + verify_members(repo, members) + result = {"status": "pass", "checksum_files": len(checks), "archives": len(archives), "assets": sum(map(len, members.values())), "mode": "verify-only"} + if args.output is not None: + output = Path(os.path.abspath(args.output)) + check_ancestors(output, missing_ok=True) + if output == repo or repo in output.parents or output in repo.parents: + raise VerificationError("Extraction directory and package directory must not contain one another") + created, reused = extract(repo, output, members) + result.update(mode="verified-extraction", extracted=created, reused=reused) + print(json.dumps(result, indent=2)) + return 0 + + +if __name__ == "__main__": + try: + raise SystemExit(main()) + except (VerificationError, OSError, ValueError, tarfile.TarError) as exc: + print(f"ERROR: {exc}", file=sys.stderr) + raise SystemExit(1) diff --git a/third_party/ARKitScenes/LICENSE b/third_party/ARKitScenes/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..be59641e5fa86473993087fd70c508c3f9ee37de --- /dev/null +++ b/third_party/ARKitScenes/LICENSE @@ -0,0 +1,20 @@ +Copyright (C) 2021 Apple Inc. All Rights Reserved. + +IMPORTANT: This Apple software is supplied to you by Apple Inc. ("Apple") in consideration of your agreement to the following terms, and your use, installation, modification or redistribution of this Apple software constitutes acceptance of these terms. If you do not agree with these terms, please do not use, install, modify or redistribute this Apple software. + +“Licensee” or “you” means you, or your employer or any other person or entity (if you are entering into this Agreement on such person or entity’s behalf), of the age required under applicable laws, rules or regulations to provide legal consent and that has legal authority to bind your employer or such other person or entity if you are entering in this Agreement on their behalf. + +In consideration of your agreement to abide by the following terms, and subject to these terms, Apple grants you a personal, non-commercial, non-exclusive license, under Apple's copyrights in this original Apple software (the "Apple Software"), to use, reproduce, modify and redistribute the Apple Software, with or without modifications, in source and/or binary forms for non-commercial purposes only; provided that if you redistribute the Apple Software in its entirety and without modifications, you must retain this notice and the following text and disclaimers in all such redistributions of the Apple Software. Neither the name, trademarks, service marks or logos of Apple Inc. may be used to endorse or promote products derived from the Apple Software without specific prior written permission from Apple. Except as expressly stated in this notice, no other rights or licenses, express or implied, are granted by Apple herein, including but not limited to any patent rights that may be infringed by your derivative works or by other works in which the Apple Software may be incorporated. + +Commercial License terms: If in every month prior to August, 2024, the monthly active users of the products or services made available by or for Licensee, or Licensee’s affiliates, was less than 700 million monthly active users, then in consideration of your agreement to abide by the following terms, and subject to these terms, Apple grants you a personal, non-exclusive license, under Apple's copyrights in this original Apple software (the "Apple Software"), to use, reproduce, modify and redistribute the Apple Software, with or without modifications, in source and/or binary forms; provided that if you redistribute the Apple Software in its entirety and without modifications, you must retain this notice and the following text and disclaimers in all such redistributions of the Apple Software. Neither the name, trademarks, service marks or logos of Apple Inc. may be used to endorse or promote products derived from the Apple Software without specific prior written permission from Apple. Except as expressly stated in this notice, no other rights or licenses, express or implied, are granted by Apple herein, including but not limited to any patent rights that may be infringed by your derivative works or by other works in which the Apple Software may be incorporated. If in any month prior to August, 2024, the monthly active users of the products or services made available by or for Licensee, or Licensee’s affiliates, is greater than or equal to 700 million monthly active users in any preceding calendar month, you must request a license from Apple, which Apple may grant to you in its sole discretion, and you are not authorized to exercise any of the rights under this Agreement unless or until Apple otherwise expressly grants you such rights + +The Apple Software is provided by Apple on an "AS IS" basis. APPLE MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS. + +IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +------------------------------------------------------------------------------- +[SOFTWARE DISTRIBUTED IN THIS REPOSITORY: +This software includes a number of subcomponents with separate copyright +notices and license terms - please see the file ACKNOWLEDGEMENTS.txt.] + + diff --git a/third_party/SOURCES.json b/third_party/SOURCES.json new file mode 100644 index 0000000000000000000000000000000000000000..9b4725d1653a3c3c243c4ef939f43f3a83b48f0b --- /dev/null +++ b/third_party/SOURCES.json @@ -0,0 +1,29 @@ +{ + "scope": "Original source notices and terms; no additional rights are granted by inclusion.", + "sources": [ + { + "path": "ScanNet/TERMS_OF_USE.pdf", + "source_url": "https://kaldir.vc.cit.tum.de/scannet/ScanNet_TOS.pdf", + "source_revision": null, + "retrieved_at_utc": "2026-10-16T06:06:53.790603+00:00", + "sha256": "aba2dbeb1e71bede5261d965c844d1e4861c26ca2cf23c9077e6d16013167715", + "size_bytes": 17893 + }, + { + "path": "ScanNetpp/TERMS_OF_USE.pdf", + "source_url": "https://scannetpp.mlsg.cit.tum.de/scannetpp/static/scannetpp-terms-of-use.pdf", + "source_revision": null, + "retrieved_at_utc": "2026-10-16T06:06:57.700232+00:00", + "sha256": "3a1dcedff65886ea305cc194f73d6aa8c2ad4e881aeb22f4e1cc6e533cf66b6a", + "size_bytes": 60990 + }, + { + "path": "ARKitScenes/LICENSE", + "source_url": "https://raw.githubusercontent.com/apple/ARKitScenes/474aaa83d7b1c9080619d8485de2d7c885c01fc5/LICENSE", + "source_revision": "474aaa83d7b1c9080619d8485de2d7c885c01fc5", + "retrieved_at_utc": "2026-10-16T06:06:58.125496+00:00", + "sha256": "1b6a8700127de50c9d56f8f33eb202a64f6f212fd4b133435f7c8b6bccd3db59", + "size_bytes": 4796 + } + ] +} diff --git a/third_party/ScanNet/TERMS_OF_USE.pdf b/third_party/ScanNet/TERMS_OF_USE.pdf new file mode 100644 index 0000000000000000000000000000000000000000..0285fcbc56eb8dc878ca6423eeecab70e7a28a23 Binary files /dev/null and b/third_party/ScanNet/TERMS_OF_USE.pdf differ diff --git a/third_party/ScanNetpp/TERMS_OF_USE.pdf b/third_party/ScanNetpp/TERMS_OF_USE.pdf new file mode 100644 index 0000000000000000000000000000000000000000..9f107d7564c1a5558d9bb9a5cea53d8710c87219 Binary files /dev/null and b/third_party/ScanNetpp/TERMS_OF_USE.pdf differ