# Isometric Cube Structure Dataset Current version: `cube-structure-2.0.0`; the initial build is preserved under `archive/v1/`. Every v2 record declares `vertical_axis: "z"`, and both `max_height`/`cubes_per_layer` and the Level 5 180-degree rotation use that same z axis. The isometric projection maps increasing z upward on screen. This agrees with `combination3d_dataset_3000`, whose corrected v2 convention also uses z as visual vertical. V2 rejects `has_ambiguous_visual_floater` scenes. The flag condition is a raised cube whose supporting cube is geometrically present but has no face visible from the fixed view. The previous build contained 2,393 flagged scenes; the released v2 contains zero. A second PNG guard requires every cube classified as visible by geometry to retain recoverable face pixels after draw ordering. Independent validation recovers visible/hidden status for all 3,000 PNGs and independently recomputes opposite-view occlusion with zero Level 5 mismatches. `cluster_counts` counts every cube assigned to a color cluster, including cubes hidden in the render. `hidden_members_per_cluster` reports those hidden members explicitly; cluster membership is geometric metadata and not merely a count of visible colored components. ## Dataset overview This dataset contains 3,000 fully synthetic, programmatically rendered isometric voxel structures and 15,000 programmatically labeled questions. No image or label was human-drawn or manually estimated. ## Generation Prompt (verbatim) ```text Build a Python script that programmatically generates a dataset of 3000 "isometric cube structure" images, for testing 3D spatial reasoning, mental rotation, and occlusion inference in AI models. === VISUAL SPEC === Each image is a square canvas (400-430px range, randomize) with a plain off-white/cream background (#F1EFE8 or similar), matching the reference image style. - Represent 3D structures as voxel/cube assemblies on an isometric grid, drawn using rhombus faces (top, left, right) per visible cube face — standard isometric cube rendering technique (each cube = 3 parallelograms: top face lightest shade, left face medium shade, right face darkest shade, all from the SAME muted teal/slate-blue color ramp, matching the reference image's blue-gray palette). - Structure generation: build each structure as a set of cube positions on a 3D integer grid (x, y, z), starting from a random footprint of 4-10 base cubes and stacking additional cubes on top following gravity rules (a cube at height h can only exist if there is a cube directly beneath it at height h-1, OR it's a height-0 base cube). - Randomize per image: - Total cube count: between 8 and 22 cubes. - Footprint shape/irregularity (not just a solid rectangular block — allow L-shapes, staggered towers, cubes with gaps, matching the organic/irregular look of the reference image). - Presence of "floating-looking but actually supported" cubes — i.e. cubes that appear ambiguous from this viewing angle because their support cube is hidden behind other cubes. This is what makes the puzzle hard: some structurally valid cubes will look like they might be floating unless the viewer mentally reconstructs the hidden support. - Isometric camera angle: keep FIXED at a standard 3-face-visible isometric projection (30-degree angle) for all images — do NOT randomize viewing angle, since ground truth for "hidden cube" questions depends on a consistent, known viewpoint. - Color: default single teal/slate ramp for ~75% of images; for ~25% of images, use TWO different color ramps to distinguish two connected sub-clusters of cubes (e.g. one "arm" of the structure in teal, another in warm gray) to support cluster-counting questions. - Every generated structure MUST be physically valid (no floating cubes with no support chain to the ground) — this is a hard constraint, verify programmatically before rendering. - Render with thin dark outline strokes (0.5-1px) on every visible face edge, matching the reference image's clean line-art look. No drop shadows, no gradients. === GROUND TRUTH DATA TO TRACK PER IMAGE === Store the full voxel grid: list of all cube positions {x, y, z}, plus for each cube whether it is fully visible, partially occluded, or fully hidden from the fixed isometric viewpoint (compute via standard isometric visibility/painter's-algorithm occlusion check). Also compute and store: - total_cube_count (ground truth for counting questions) - visible_cube_count (cubes with at least one face visible) - hidden_cube_count (cubes with zero visible faces from this viewpoint) - base_layer_count (cubes at z=0, i.e. touching the ground) - max_height (number of layers/z-levels) - cubes_per_layer: dict of {z_level: count} - color_cluster_count: 1 or 2 depending on whether color splitting was used === GROUND TRUTH GENERATION — EXACTLY 4 QUESTIONS PER IMAGE, ORDERED BY DIFFICULTY === LEVEL 1 - Simple Description (always include): "How many cubes make up this structure in total? Answer with a number in curly brackets, e.g. {12}." ground_truth = total_cube_count (This requires inferring hidden cubes too, not just counting visible faces — make this explicit in a short accompanying instruction line if needed, or keep it implicit and let this be the "hardest simple-sounding question" by design.) LEVEL 2 - Basic Relational (always include): "How many cubes are touching the ground (bottom layer)? Answer with a number in curly brackets, e.g. {5}." ground_truth = base_layer_count LEVEL 3 - Comparative/Structural (pick ONE at random per image from): a) "How many total layers (levels of height) does this structure have? Answer with a number in curly brackets, e.g. {3}." ground_truth = max_height b) "Which layer (counting from the ground as layer 1) has the most cubes? Answer with a number in curly brackets, e.g. {2}." ground_truth = the z-level (1-indexed) with the highest cube count (if tied, pick the lowest such layer and note tie in metadata) c) "If color clusters are present: how many cubes are in the [color_name] cluster?" ground_truth = count of cubes in that color group (only use when color_cluster_count == 2; otherwise fall back to (a)) LEVEL 4 - Complex/Compound (pick ONE at random per image from): a) "How many cubes in this structure are completely hidden from view (not visible from any angle in this image)? Answer with a number in curly brackets, e.g. {2}." ground_truth = hidden_cube_count b) "Is this structure physically stable — i.e., does every cube have support beneath it with no floating cubes? Answer yes or no." ground_truth = "yes" always (since generation enforces validity) — BUT for ~10% of images, deliberately render one additional cube in a position that VISUALLY appears to float relative to camera angle even though it may or may not be supported, to test whether the model over- or under-trusts visual impression. Track ground truth precisely based on actual generated structure, not visual impression. c) "If this structure were rotated 180 degrees around the vertical (z) axis, how many currently-hidden cubes would become visible? Answer with a number in curly brackets, e.g. {3}." ground_truth = compute by re-running the visibility/occlusion check from the opposite viewpoint (180-degree rotation) and counting cubes that flip from hidden->visible === METADATA (per image) === { "id": "cube_structure_0001", "image_path": "images/cube_structure_0001.png", "canvas_size": [412, 420], "total_cube_count": 15, "visible_cube_count": 12, "hidden_cube_count": 3, "base_layer_count": 6, "max_height": 4, "cubes_per_layer": {"1": 6, "2": 4, "3": 3, "4": 2}, "color_cluster_count": 1, "has_ambiguous_visual_floater": false, "seed": 1, "difficulty_score":