OV-CV-BPY: A Modular Pipeline for Reconstructing Primitive Character Shapes from Orthogonal-View Images

The rapid progress of generative AI has reshaped digital content creation workflows across text, images, videos, and 3D representations. In 3D modeling, recent advances enable the generation of high-fidelity assets from text or images within a few minutes. Nevertheless, existing approaches remain limited in part-level generation and often produce meshes with irregular topology. These issues hinder their practical application in modeling for gaming and animation, where clean topology and modular part organization are essential. This problem can be formulated as follows. Let a character $C$ be composed of mesh parts $m_1, m_2, ..., m_n$. Each mesh is a set of vertices, $mesh = {(x_k, y_k, z_k) | k = 1, 2, ..., N}$, where N is the total number of vertices of that part. Existing single-image or few-image generative pipelines typically recover $C$ as a single, densely connected mesh rather than as a set of independently addressable parts $m_i$, which is what a part-level, animation-ready workflow requires. To address this, this paper proposes OV-CV-BPY (Orthogonal View-Computer Vision-Blender Python), a lightweight and modular algorithm for character part generation. The method reconstructs 3D features from orthogonal image segmentations and employs Blender Python scripting to generate shapes. In this study, the algorithm is scoped to primitive cube generation and demonstrates its application using a Doraemon reference image [1] segmented into four orthogonal views: front, left, back, and right. Rights statement: Doraemon is a trademark of Fujiko-Pro/Shogakukan/TV Asahi. The reference artwork used in this study, created by Ashutosh Kadam [1], is used solely for non-commercial academic research and educational demonstration purposes; no affiliation with or endorsement by the rights holders is implied. The resulting manually post-processed 3D model is compared with a Doraemon model produced by Hunyuan3D v2.5 and v3.0. This work aims to provide a foundation for part-level character modeling with clean topology, supporting more practical workflows in digital production pipelines. Each modular block within the algorithm is designed for extensibility, offering opportunities for developers and artists to build custom automation tools tailored to specific workflows. This paper makes the following contributions: 1) A modular, four-stage pipeline (image preprocessing, 2D segmentation, 3D feature reconstruction, Blender-Python generation) with an explicit mathematical formulation for mapping orthogonal 2D image coordinates into a shared 3D Cartesian space. 2) A per-view coordinate normalization scheme, adapted from the OpenGL normalized-device-coordinate-to-window-space viewport transform, together with an axis-aligned bounding-box (AABB) reconstruction procedure that combines four orthogonal views into a per-part 3D volume approximation. 3) A working, end-to-end Blender Python implementation, demonstrated on a 29-part character case study, that outputs an editable primitive-cube block out in under one second. 4) A comparative case study against a general-purpose LLM-generated Blender script and against Hunyuan3D v2.5/v3.0, reporting matched mesh statistics (vertex, edge, face, and triangle counts) alongside generation time, to characterize the trade-off between part-level editability and out-of-the-box geometric fidelity.

Two handcrafted approaches dominate character modelling in the current 3D games industry: polygonal (box) modelling and digital sculpting [3, 5]. Polygonal modelling gives an artist full control over vertices, edges, and faces and produces topology that is portable across software and straightforward to rig, but its speed is bound by artist skill and is slow for complex or organic shapes. Sculpting mirrors traditional clay work and is well suited to high-detail, irregular geometry, but the resulting high-resolution mesh requires retopology before it can be used in real-time applications. OV-CV-BPY targets the earliest stage of both workflows - producing a rough, part-organized block out - rather than replacing either technique.

Classical 3D reconstruction recovers geometry from captured images or sensor data. Photogrammetry reconstructs high-detail, realistic models from many calibrated photographs, but is computationally expensive, requires good image coverage, and is sensitive to lighting [6]. Neural Radiance Fields (NeRF) [7] and 3D Gaussian Splatting [8] relax the image-count and lighting requirements and can reproduce effects such as glass and reflections that photogrammetry cannot, but both require per-scene training, and their outputs - a neural field or a set of Gaussians rather than an editable mesh - are not directly usable in a box-modelling workflow without an additional, lossy mesh-extraction step [6, 7, 8].

Diffusion-, transformer-, and GAN-based 3D shape generation models such as Unique3D [9] and Hunyuan3D [2] can generate a textured mesh from a single image with high visual quality in a short time. A recent end-to-end platform, Hunyuan3D Studio [16], further automates part-level shape generation, mesh generation, and semantic UV unwrapping for production use, though its part-level generation feature was not yet publicly testable at the time of this study. Across these generative approaches, output quality drops for complex, full-body characters, fine soft/hard-edge detail is often lost, and - critically for animation pipelines - the result is typically a single, densely connected mesh that is difficult to restructure into independent, riggable parts. This motivates integrating segmentation directly into the reconstruction step, so that part boundaries are established before geometry is generated, rather than being inferred afterward.

Two prior approaches are closely related to OV-CV-BPY. Huang, Xie, and Fukusato [10] allow an artist to manually annotate orthogonal-view drawings while modelling a character with a generative shape, improving the interactive modelling workflow; OV-CV-BPY differs by automating the view-to-3D mapping itself (via SAM2-assisted segmentation and the coordinate-normalization procedure in Section III) rather than relying on manual annotation of the 3D shape during modelling. Buchanan, Mukundan, and Doggett [11] reconstruct a textured mesh from a single-view image by adapting skeletonization to the character's silhouette and texturing the result; this avoids any training requirement but, by the authors' own account, performs poorly on posed characters, characters covered by clothing, or characters carrying equipment. OV-CV-BPY's use of four orthogonal views and explicit per-part segmentation is intended to remain robust to exactly these cases, at the cost of requiring multiple curated input images rather than one.

OV-CV-BPY is composed of four stages: Image Preprocessing, 2D Mesh Polygon Mask Segmentation, 3D Feature Reconstruction, and BPY Mesh Generation.

The input is a set of four orthogonal-view images (front, left, back, right), each assumed to have an equal width and height (1:1 aspect ratio). The final output is a Blender file containing the reconstructed character meshes, ready for further refinement and detailing. Fig. 1 shows the pipeline's block diagram.

The character is treated as a composition of named mesh parts (e.g., head, right hand). Each part is segmented from every orthogonal view using CVAT's interactive segmentation tool backed by the SAM 2 model [3], which requires only minimal user input (a bounding box or point prompt) per part. Each segmented instance is labelled with a “name” and “view” attribute so that the same part can be tracked and aggregated across the four views, and the result is exported as a COCO 1.0 annotation file.

This stage converts the 2D annotations into 3D axis-aligned bounding boxes (AABBs) through three sub-steps: annotation preprocessing, coordinate normalization, and AABB reconstruction (Fig. 2). Annotation preprocessing groups the polygon-mask annotations by part name across the four views, so that, for example, all segmentations labelled “head" are collected into a single record regardless of which view they came from. Coordinate normalization maps each part's pixel-space polygon coordinates into a per-view Cartesian coordinate system. This is adapted from the OpenGL viewport transform, which converts a normalized-device-coordinate value $x_{ndc}$ into window space as denoted in Eq. (1), where $x$ is the viewport origin offset. Setting the viewport offset to zero and inverting this relation for a square image of width/height $W$ gives the per-axis mapping used in Eq. (2). Here $H$ denotes the horizontal pixel axis, mapped to the Cartesian $y-axis$ for the front/back views and to the Cartesian $x-axis$ for the left/right views, and $V$ denotes the vertical pixel axis, mapped to the Cartesian $z-axis$ in every view (Table I). Applying Eq. (2) to every polygon vertex converts a part's 2D image-space mask in each view into a set of points in a shared 3D Cartesian frame. AABB reconstruction then takes, for each mesh part, the full set of $N$ Cartesian points collected across its available views and computes the coordinate-wise minimum and maximum as denoted in Eq. (5) - Eq. (7). This pair of points defines the spatial extent of the part and is passed to the mesh-generation stage.

For each mesh part, the AABB's center point and size are computed from its minimum and maximum coordinates. A cube primitive is added at the origin, renamed to the part's mesh name, scaled to the AABB's size, and translated to the AABB's center, using Blender's Python API. The result is saved as a single Blender file containing one primitive cube per character part, ready for manual refinement using box-modelling or digital-sculpting techniques.

The pipeline is implemented in Python 3.11.7 in Visual Studio Code with the Blender Development v0.0.26 extension, on Windows 11 with an AMD Ryzen 9 5900HS processor, an NVIDIA RTX 1650 GPU, and 16GB RAM. Blender 4.4.3 is used for mesh generation. The Doraemon orthogonal-view reference image [1] was cropped into four separate images (front, left, back, right) with the background removed, using the online editor Photopea. A small Streamlit-based tool was built to let a user interactively resize the four images to a consistent 608×608 resolution before segmentation. Segmentation used CVAT's SAM 2-backed interactive tool with a single label class (“mesh”) and “name”/“view” attributes, producing 29 annotated body parts exported in COCO 1.0 format. To evaluate the algorithm, the same orthogonal-view input was also used to generate a comparison mesh via a Blender Python script produced by the free version of ChatGPT (using sphere primitives), and via the Hunyuan3D v2.5 and v3.0 web models with their multiview-input option, which accepts the same four orthogonal views [2, 4]. Code, annotation data, and the generated Blender files are available at: https://https://github.com/shsaw-doraemon/OV-CV-BPY.

Applying Eq. (2) and Eq. (3) to the segmented polygon masks correctly recovers a per-view Cartesian plot of every part for all four views (Fig. 4), and Eq. (5) - Eq. (7) correctly recovers a bounding box enclosing each part's mask in every view (Fig. 5), confirming that the mapping and reconstruction procedure behaves as intended on this case study.

Fig. 6 shows OV-CV-BPY's raw primitive-cube output prior to manual post-processing, for all four views. Table II compares meshes generated with the same orthogonal-view input by three methods: a Blender Python script generated by the free version of ChatGPT (using sphere primitives), OV-CV-BPY without manual post-processing, and Hunyuan3D v2.5 with multiview input at 500k faces without retopology. Table III compares OV-CV-BPY's output after manual post-processing (subdivision modifier and grouped symmetry objects) against Hunyuan3D v2.5 (50k faces, quad retopology) and Hunyuan3D v3.0 (500k faces, quad retopology). OV-CV-BPY's raw output uses roughly two orders of magnitude fewer vertices than Hunyuan3D v2.5's untouched 500k-face output, and is generated over two orders of magnitude faster; after manual post-processing, OV-CV-BPY's part count (18, reflecting merged/grouped symmetry objects) remains close to Hunyuan3D's retopologies outputs while remaining organized as separately editable objects rather than a single mesh. Hunyuan3D v2.5 and v3.0 generate a single-object, high-fidelity mesh with excellent geometric detail and topology within minutes, but that single-object structure is hard to restructure into independent, riggable parts; a like-for-like comparison of part-level segmentation quality against Hunyuan3D was not possible, since Hunyuan3D Studio's part-level generation feature [16] was not yet publicly available for testing at the time of this study.

This case study reconstructs one character from one set of orthogonal images; the results demonstrate feasibility rather than general validity across character types, poses, or clothing complexity, and no segmentation-accuracy metric (e.g., mask IoU against a manually corrected reference) was measured. AABB-based reconstruction is sufficient to generate basic primitive shapes such as cubes, but does not capture finer geometric detail; incorporating additional views (e.g., top-down), analyzing vertex distribution within each part, and extracting semantic features from the input images are directions that could improve reconstruction fidelity without abandoning the part-level, primitive-based approach. A further practical constraint was limited local GPU compute, which made it infeasible to fine-tune open-source 3D generative models for a more controlled, apples-to-apples comparison without relying on paid cloud compute.

This paper proposed OV-CV-BPY, a modular pipeline that reconstructs primitive, part-organized 3D shapes from segmented orthogonal-view character images, using a coordinate-normalization procedure adapted from the OpenGL viewport transform, axis-aligned bounding-box reconstruction, and Blender Python mesh generation. Applied to a 29-part, four-view case study, the pipeline generated a cube-based block out in under one second, at a fraction of the vertex count of a comparable Hunyuan3D generation, and orders of magnitude faster. The comparison highlights a structural trade-off: current generative models offer superior out-of-the-box geometric detail but produce a single, hard-to-restructure mesh, whereas OV-CV-BPY offers immediate part-level editability at the cost of manual geometric refinement. As a single-case-study demonstration, these results establish feasibility rather than general validity; quantitative segmentation-accuracy evaluation, testing on additional characters and poses, and incorporating additional views or semantic features are needed before the approach's benefits can be generalized beyond this example.

The 3D Feature Reconstruction module could be extended to identify parent-child object relationships by analyzing polygon-mask area, enabling the BPY Mesh Generation module to apply parent-child binding and armature-based bending between parts. Adding a local (part-relative) bounding box after the global AABB reconstruction step could further refine the generated shapes. The segmentation process could also be further automated while retaining a manual-adjustment path for misdetections. More broadly, as users' 3D modelling expertise with the pipeline grows, the modular scripting design leaves room for community-built add-ons and further automation tools tailored to specific character-modelling workflows.