complete stringlengths 118 307 | file_path stringclasses 44
values | ground_truth listlengths 1 1 | gt_summary stringlengths 247 426 | code stringlengths 142 239 | id int64 0 499 | ambiguous stringclasses 17
values | missing_info stringlengths 62 228 | mistake stringlengths 134 394 | mistake_type stringclasses 4
values |
|---|---|---|---|---|---|---|---|---|---|
Reconstruct a 3D asset from the image at {input_file_path}. Ensure the mesh is medium quality. I need a ply file. Store the result at ./outputs/Auditorium.ply. | ./data/source/singleview/scene/Auditorium.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": "Medium quality",
"speed": null,
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/Auditorium.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/Auditorium.jpg </file_path>
<extra_info> Constraints: [quality: Medium quality, output_format: ply]; Output Pat... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/Auditorium.jpg', output_path='./outputs/Auditorium.ply', model='vggt', conf_thres=20.0) | 100 | Process {input_file_path}. | Process the single-view image to create a 3D representation. I require a certain quality. Export format: 3D model. Store the generated model. | Reconstruct a 3D asset from the image at ./data/source/singleview/scene/Auditorium.glb. Ensure the mesh is medium quality. I need a ply file. Store the result at ./outputs/Auditorium.ply. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. Expect fast speed processing. The result should be saved in ./outputs/Auditorium.glb. | ./data/source/singleview/scene/Auditorium.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": "Fast speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/Auditorium.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/Auditorium.jpg </file_path>
<extra_info> Constraints: [speed: Fast speed]; Output Path: ./outputs/Auditorium... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/Auditorium.jpg', output_path='./outputs/Auditorium.glb', model='vggt', conf_thres=20.0) | 101 | Process {input_file_path}. | Process the single-view image to create a 3D representation. The generation speed should be specified. Save the output to somewhere. | Load image ./data/source/singleview/scene/Auditorium.obj and reconstruct it into 3D asset. Expect fast speed processing. The result should be saved in ./outputs/Auditorium.glb. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. I need a glb file. Ensure dense point cloud. The result should be saved in ./outputs/Ballroom.glb. | ./data/source/singleview/scene/Ballroom.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/Ballroom.glb",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/Ballroom.jpg </file_path>
<extra_info> Constraints: [output_format: glb, features: Dense point cloud]; Output P... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/Ballroom.jpg', output_path='./outputs/Ballroom.glb', model='vggt', conf_thres=20.0) | 102 | Fix {input_file_path} to 3D. | Process the single-view image to create a 3D representation. It should have specific attributes. Export format: 3D model. Store the generated model. | Reconstruct a 3D asset from the image at ./data/source/singleview/scene/Ballroom.ply. I need a glb file. Ensure dense point cloud. The result should be saved in ./outputs/Ballroom.glb. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. I need a ply file. Ensure dense point cloud. Store the result at ./outputs/Ballroom.ply. | ./data/source/singleview/scene/Ballroom.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/Ballroom.ply",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/Ballroom.jpg </file_path>
<extra_info> Constraints: [output_format: ply, features: Dense point cloud]; Outpu... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/Ballroom.jpg', output_path='./outputs/Ballroom.ply', model='vggt', conf_thres=20.0) | 103 | Do something with {input_file_path}. | Reconstruct a 3D asset from the image. It should have specific attributes. Export format: 3D model. The result should be saved in a location. | Load image ./data/source/singleview/scene/Ballroom.obj and reconstruct it into 3D asset. I need a ply file. Ensure dense point cloud. Store the result at ./outputs/Ballroom.ply. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. I need it processed with fast speed. Set the confidence threshold to 23. Store the result at ./outputs/Courtroom.glb. | ./data/source/singleview/scene/Courtroom.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": "Fast speed",
"conf_thres": 23,
"output_format": null,
"output_path": "./outputs/Courtroom.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/Courtroom.jpg </file_path>
<extra_info> Constraints: [speed: Fast speed, conf_thres: 23]; Output Path: ./out... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/Courtroom.jpg', output_path='./outputs/Courtroom.glb', model='vggt', conf_thres=23) | 104 | Do something with {input_file_path}. | Load image and reconstruct it into 3D asset. Expect appropriate processing speed. Use a confidence cutoff of a value. Store the generated model. | Load image {input_file_path} and reconstruct it into 3D asset. I need it processed with fast speed. Set the confidence threshold to -23. Store the result at ./outputs/Courtroom.glb. | parameter |
Reconstruct a 3D asset from the image at {input_file_path}. I require medium quality output. Save the output as a glb file. Store the result at ./outputs/Courtroom.glb. | ./data/source/singleview/scene/Courtroom.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": "Medium quality",
"speed": null,
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/Courtroom.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/Courtroom.jpg </file_path>
<extra_info> Constraints: [quality: Medium quality, output_format: glb]; Output Path... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/Courtroom.jpg', output_path='./outputs/Courtroom.glb', model='vggt', conf_thres=20.0) | 105 | Fix {input_file_path} to 3D. | Reconstruct a 3D asset from the image. The model quality should be specified. Export format: 3D model. Save the output to somewhere. | Reconstruct a 3D asset from the image at ./data/source/singleview/scene/Courtroom.glb. I require medium quality output. Save the output as a glb file. Store the result at ./outputs/Courtroom.glb. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. The model quality should be medium quality. I need it processed with fast speed. Save the output to ./outputs/M60.ply. | ./data/source/singleview/scene/M60.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": "Medium quality",
"speed": "Fast speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/M60.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/M60.jpg </file_path>
<extra_info> Constraints: [quality: Medium quality, speed: Fast speed]; Output... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/M60.jpg', output_path='./outputs/M60.ply', model='vggt', conf_thres=20.0) | 106 | Fix {input_file_path} to 3D. | Perform single-view 3D reconstruction. The model quality should be specified. The generation speed should be specified. The result should be saved in a location. | Perform single-view 3D reconstruction using ./data/source/singleview/scene/M60.ply as input. The model quality should be medium quality. I need it processed with fast speed. Save the output to ./outputs/M60.ply. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. Save the output as a ply file. It should be a dense point cloud. Set the confidence threshold to 25. Store the result at ./outputs/M60.ply. | ./data/source/singleview/scene/M60.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": null,
"conf_thres": 25,
"output_format": "ply",
"output_path": "./outputs/M60.ply",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/M60.jpg </file_path>
<extra_info> Constraints: [output_format: ply, features: Den... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/M60.jpg', output_path='./outputs/M60.ply', model='vggt', conf_thres=25) | 107 | Do something with {input_file_path}. | Load image and reconstruct it into 3D asset. Set the confidence threshold to a value. Consider that this has particular characteristics. Export format: 3D model. Store the generated model. | Process the single-view image located at {input_file_path} to create a 3D representation. Save the output as a ply file. It should be a dense point cloud. Set the confidence threshold to 2500. Store the result at ./outputs/M60.ply. | parameter |
Load image {input_file_path} and reconstruct it into 3D asset. Set the confidence threshold to 19. Store the result at ./outputs/Museum.ply. | ./data/source/singleview/scene/Museum.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": null,
"conf_thres": 19,
"output_format": null,
"output_path": "./outputs/Museum.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/Museum.jpg </file_path>
<extra_info> Constraints: [conf_thres: 19]; Output Path: ./outputs/Museum.ply </extr... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/Museum.jpg', output_path='./outputs/Museum.ply', model='vggt', conf_thres=19) | 108 | Fix {input_file_path} to 3D. | Reconstruct a 3D asset from the image. Set the confidence threshold to a value. The result should be saved in a location. | Load image {input_file_path} and reconstruct it into 3D asset. Set the confidence threshold to 1900. Store the result at ./outputs/Museum.ply. | parameter |
Reconstruct a 3D asset from the image at {input_file_path}. I require medium quality output. Save the output as a glb file. Use a confidence cutoff of 25. The result should be saved in ./outputs/Museum.glb. | ./data/source/singleview/scene/Museum.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": "Medium quality",
"speed": null,
"conf_thres": 25,
"output_format": "glb",
"output_path": "./outputs/Museum.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/Museum.jpg </file_path>
<extra_info> Constraints: [quality: Medium quality, output_format: glb, conf_thres: 25]... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/Museum.jpg', output_path='./outputs/Museum.glb', model='vggt', conf_thres=25) | 109 | Process {input_file_path}. | Process the single-view image to create a 3D representation. I require a certain quality. Filter out points with confidence below a value. I need a file. Store the generated model. | Reconstruct a 3D asset from the image at {input_file_path}. I require medium quality output. Save the output as a glb file. Use a confidence cutoff of -25. The result should be saved in ./outputs/Museum.glb. | parameter |
Reconstruct a 3D asset from the image at {input_file_path}. Export format: ply. The result should be saved in ./outputs/Panther.ply. | ./data/source/singleview/scene/Panther.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/Panther.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/Panther.jpg </file_path>
<extra_info> Constraints: [output_format: ply]; Output Path: ./outputs/Panther.ply </e... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/Panther.jpg', output_path='./outputs/Panther.ply', model='vggt', conf_thres=20.0) | 110 | Make 3D from {input_file_path}. | Reconstruct a 3D asset from the image. I need a file. The result should be saved in a location. | Reconstruct a 3D asset from the image at ./data/source/singleview/scene/Panther.obj. Export format: ply. The result should be saved in ./outputs/Panther.ply. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. Expect fast speed processing. The result should be saved in ./outputs/Panther.glb. | ./data/source/singleview/scene/Panther.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": "Fast speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/Panther.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/Panther.jpg </file_path>
<extra_info> Constraints: [speed: Fast speed]; Output Pa... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/Panther.jpg', output_path='./outputs/Panther.glb', model='vggt', conf_thres=20.0) | 111 | Process {input_file_path}. | Process the single-view image to create a 3D representation. I need it generated at a certain speed. Store the generated model. | Process the single-view image located at ./data/source/singleview/scene/Panther.glb to create a 3D representation. Expect fast speed processing. The result should be saved in ./outputs/Panther.glb. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. Use a confidence cutoff of 17. Store the result at ./outputs/bonsai.ply. | ./data/source/singleview/scene/bonsai.JPG | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": null,
"conf_thres": 17,
"output_format": null,
"output_path": "./outputs/bonsai.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/bonsai.JPG </file_path>
<extra_info> Constraints: [conf_thres: 17]; Output Path: ./outputs/bonsai.ply </extra_i... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/bonsai.JPG', output_path='./outputs/bonsai.ply', model='vggt', conf_thres=17) | 112 | Do something with {input_file_path}. | Reconstruct a 3D asset from the image. Use a confidence cutoff of a value. Store the generated model. | Reconstruct a 3D asset from the image at {input_file_path}. Use a confidence cutoff of 1700. Store the result at ./outputs/bonsai.ply. | parameter |
Load image {input_file_path} and reconstruct it into 3D asset. Expect fast speed processing. Ensure dense point cloud. Store the result at ./outputs/bonsai.ply. | ./data/source/singleview/scene/bonsai.JPG | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": "Fast speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/bonsai.ply",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/bonsai.JPG </file_path>
<extra_info> Constraints: [speed: Fast speed, features: Dense point cloud]; Output P... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/bonsai.JPG', output_path='./outputs/bonsai.ply', model='vggt', conf_thres=20.0) | 113 | Fix {input_file_path} to 3D. | Perform single-view 3D reconstruction. Expect appropriate processing speed. Focus on certain features. The result should be saved in a location. | Load image ./data/source/singleview/scene/bonsai.ply and reconstruct it into 3D asset. Expect fast speed processing. Ensure dense point cloud. Store the result at ./outputs/bonsai.ply. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. The reconstruction speed should be fast speed. Set the confidence threshold to 19. The result should be saved in ./outputs/counter.ply. | ./data/source/singleview/scene/counter.JPG | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": "Fast speed",
"conf_thres": 19,
"output_format": null,
"output_path": "./outputs/counter.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/counter.JPG </file_path>
<extra_info> Constraints: [speed: Fast speed, conf_thres... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/counter.JPG', output_path='./outputs/counter.ply', model='vggt', conf_thres=19) | 114 | Make 3D from {input_file_path}. | Perform single-view 3D reconstruction. Expect appropriate processing speed. Set the confidence threshold to a value. The result should be saved in a location. | Process the single-view image located at {input_file_path} to create a 3D representation. The reconstruction speed should be fast speed. Set the confidence threshold to 1900. The result should be saved in ./outputs/counter.ply. | parameter |
Load image {input_file_path} and reconstruct it into 3D asset. The reconstruction speed should be fast speed. Export format: glb. Set the confidence threshold to 18. Save the output to ./outputs/counter.glb. | ./data/source/singleview/scene/counter.JPG | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": "Fast speed",
"conf_thres": 18,
"output_format": "glb",
"output_path": "./outputs/counter.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/counter.JPG </file_path>
<extra_info> Constraints: [speed: Fast speed, output_format: glb, conf_thres: 18]; ... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/counter.JPG', output_path='./outputs/counter.glb', model='vggt', conf_thres=18) | 115 | Do something with {input_file_path}. | Load image and reconstruct it into 3D asset. I need it generated at a certain speed. Set the confidence threshold to a value. I need a file. Store the generated model. | Load image {input_file_path} and reconstruct it into 3D asset. The reconstruction speed should be fast speed. Export format: glb. Set the confidence threshold to 1800. Save the output to ./outputs/counter.glb. | parameter |
Load image {input_file_path} and reconstruct it into 3D asset. Expect fast speed processing. Store the result at ./outputs/kitchen.glb. | ./data/source/singleview/scene/kitchen.JPG | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": "Fast speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/kitchen.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/kitchen.JPG </file_path>
<extra_info> Constraints: [speed: Fast speed]; Output Path: ./outputs/kitchen.glb <... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/kitchen.JPG', output_path='./outputs/kitchen.glb', model='vggt', conf_thres=20.0) | 116 | Fix {input_file_path} to 3D. | Process the single-view image to create a 3D representation. The generation speed should be specified. Store the generated model. | Load image ./data/source/singleview/scene/kitchen.glb and reconstruct it into 3D asset. Expect fast speed processing. Store the result at ./outputs/kitchen.glb. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. Save the output as a glb file. Focus on dense point cloud. Filter out points with confidence below 22. Save the output to ./outputs/kitchen.glb. | ./data/source/singleview/scene/kitchen.JPG | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": null,
"conf_thres": 22,
"output_format": "glb",
"output_path": "./outputs/kitchen.glb",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/kitchen.JPG </file_path>
<extra_info> Constraints: [output_format: glb, features: Dense point cloud... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/kitchen.JPG', output_path='./outputs/kitchen.glb', model='vggt', conf_thres=22) | 117 | Make 3D from {input_file_path}. | Load image and reconstruct it into 3D asset. Use a confidence cutoff of a value. Consider that this has particular characteristics. Save the output to a file. The result should be saved in a location. | Perform single-view 3D reconstruction using {input_file_path} as input. Save the output as a glb file. Focus on dense point cloud. Filter out points with confidence below 2200. Save the output to ./outputs/kitchen.glb. | parameter |
Process the single-view image located at {input_file_path} to create a 3D representation. I need it processed with fast speed. Export format: glb. The result should be saved in ./outputs/room.glb. | ./data/source/singleview/scene/room.JPG | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": "Fast speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/room.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/room.JPG </file_path>
<extra_info> Constraints: [speed: Fast speed, output_format... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/room.JPG', output_path='./outputs/room.glb', model='vggt', conf_thres=20.0) | 118 | Make 3D from {input_file_path}. | Perform single-view 3D reconstruction. I need it generated at a certain speed. I need a file. Save the output to somewhere. | Process the single-view image located at ./data/source/singleview/scene/room.glb to create a 3D representation. I need it processed with fast speed. Export format: glb. The result should be saved in ./outputs/room.glb. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. Save the output as a ply file. Focus on dense point cloud. Filter out points with confidence below 20. Store the result at ./outputs/room.ply. | ./data/source/singleview/scene/room.JPG | [
{
"task": "Single-View 3D Reconstruction",
"usage": "scene",
"quality": null,
"speed": null,
"conf_thres": 20,
"output_format": "ply",
"output_path": "./outputs/room.ply",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/scene/room.JPG </file_path>
<extra_info> Constraints: [output_format: ply, features: Dense point cloud, conf_thres... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/scene/room.JPG', output_path='./outputs/room.ply', model='vggt', conf_thres=20) | 119 | Fix {input_file_path} to 3D. | Perform single-view 3D reconstruction. Set the confidence threshold to a value. Focus on certain features. Export format: 3D model. The result should be saved in a location. | Load image {input_file_path} and reconstruct it into 3D asset. Save the output as a ply file. Focus on dense point cloud. Filter out points with confidence below -20. Store the result at ./outputs/room.ply. | parameter |
Reconstruct a 3D asset from the image at {input_file_path}. Ensure the mesh is ultra-high quality. The reconstruction speed should be slow speed. Export format: glb. Save the output to ./outputs/scan10.glb. | ./data/source/singleview/object/scan10.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Ultra-High quality",
"speed": "Slow speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan10.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan10.jpg </file_path>
<extra_info> Constraints: [quality: Ultra-High quality, speed: Slow speed, output_form... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan10.jpg', output_path='./outputs/scan10.glb', model='hunyuan') | 120 | Make 3D from {input_file_path}. | Perform single-view 3D reconstruction. I require a certain quality. I need it generated at a certain speed. Export format: 3D model. The result should be saved in a location. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan10.stl. Ensure the mesh is ultra-high quality. The reconstruction speed should be slow speed. Export format: glb. Save the output to ./outputs/scan10.glb. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. The reconstruction speed should be slow speed. Save the output as a obj file. Store the result at ./outputs/scan10.obj. | ./data/source/singleview/object/scan10.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Slow speed",
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan10.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan10.jpg </file_path>
<extra_info> Constraints: [speed: Slow speed, output_format: obj]; Output ... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan10.jpg', output_path='./outputs/scan10.obj', model='hunyuan') | 121 | Do something with {input_file_path}. | Process the single-view image to create a 3D representation. Expect appropriate processing speed. Export format: 3D model. The result should be saved in a location. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan10.ply as input. The reconstruction speed should be slow speed. Save the output as a obj file. Store the result at ./outputs/scan10.obj. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. The model quality should be ultra-high quality. I need it processed with slow speed. It should be a mesh with detailed geometry. The result should be saved in ./outputs/scan10.glb. | ./data/source/singleview/object/scan10.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Ultra-High quality",
"speed": "Slow speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan10.glb",
"extra_info": "Mesh with detailed geometry"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan10.jpg </file_path>
<extra_info> Constraints: [quality: Ultra-High quality, ... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan10.jpg', output_path='./outputs/scan10.glb', model='hunyuan') | 122 | Fix {input_file_path} to 3D. | Process the single-view image to create a 3D representation. Ensure the result quality is defined. The generation speed should be specified. It should have specific attributes. The result should be saved in a location. | Process the single-view image located at ./data/source/singleview/object/scan10.ply to create a 3D representation. The model quality should be ultra-high quality. I need it processed with slow speed. It should be a mesh with detailed geometry. The result should be saved in ./outputs/scan10.glb. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. Ensure the mesh is high quality. I need it processed with medium speed. It should be a high-fidelity mesh. Save the output to ./outputs/scan10.ply. | ./data/source/singleview/object/scan10.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": "Medium speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan10.ply",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan10.jpg </file_path>
<extra_info> Constraints: [quality: High quality, speed: Medium speed, features: High-... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan10.jpg', output_path='./outputs/scan10.ply', model='trellis') | 123 | Process {input_file_path}. | Perform single-view 3D reconstruction. The model quality should be specified. The generation speed should be specified. Consider that this has particular characteristics. Store the generated model. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan10.glb. Ensure the mesh is high quality. I need it processed with medium speed. It should be a high-fidelity mesh. Save the output to ./outputs/scan10.ply. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. The reconstruction speed should be medium speed. Save the output as a ply file. Save the output to ./outputs/scan10.ply. | ./data/source/singleview/object/scan10.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Medium speed",
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan10.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan10.jpg </file_path>
<extra_info> Constraints: [speed: Medium speed, output_format: ply]; Output Path: .... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan10.jpg', output_path='./outputs/scan10.ply', model='trellis') | 124 | Do something with {input_file_path}. | Process the single-view image to create a 3D representation. The generation speed should be specified. Save the output to a file. Save the output to somewhere. | Load image ./data/source/singleview/object/scan10.stl and reconstruct it into 3D asset. The reconstruction speed should be medium speed. Save the output as a ply file. Save the output to ./outputs/scan10.ply. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. Ensure the mesh is high quality. Save the output to ./outputs/scan10.obj. | ./data/source/singleview/object/scan10.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": null,
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan10.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan10.jpg </file_path>
<extra_info> Constraints: [quality: High quality]; Outpu... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan10.jpg', output_path='./outputs/scan10.obj', model='trellis') | 125 | Do something with {input_file_path}. | Reconstruct a 3D asset from the image. The model quality should be specified. Store the generated model. | Process the single-view image located at ./data/source/singleview/object/scan10.obj to create a 3D representation. Ensure the mesh is high quality. Save the output to ./outputs/scan10.obj. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. The reconstruction speed should be fast speed. Export format: glb. The result should be saved in ./outputs/scan10.glb. | ./data/source/singleview/object/scan10.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Fast speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan10.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan10.jpg </file_path>
<extra_info> Constraints: [speed: Fast speed, output_format: glb]; Output Path: ./outp... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan10.jpg', output_path='./outputs/scan10.glb', model='vggt', conf_thres=20.0) | 126 | Fix {input_file_path} to 3D. | Reconstruct a 3D asset from the image. I need it generated at a certain speed. Export format: 3D model. The result should be saved in a location. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan10.obj. The reconstruction speed should be fast speed. Export format: glb. The result should be saved in ./outputs/scan10.glb. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. The reconstruction speed should be fast speed. Save the output as a ply file. It should be a dense point cloud. The result should be saved in ./outputs/scan10.ply. | ./data/source/singleview/object/scan10.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Fast speed",
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan10.ply",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan10.jpg </file_path>
<extra_info> Constraints: [speed: Fast speed, output_format: ply, features... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan10.jpg', output_path='./outputs/scan10.ply', model='vggt', conf_thres=20.0) | 127 | Fix {input_file_path} to 3D. | Process the single-view image to create a 3D representation. Expect appropriate processing speed. Consider that this has particular characteristics. Export format: 3D model. Store the generated model. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan10.stl as input. The reconstruction speed should be fast speed. Save the output as a ply file. It should be a dense point cloud. The result should be saved in ./outputs/scan10.ply. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. Save the output as a obj file. It should be a mesh with detailed geometry. Save the output to ./outputs/scan11.obj. | ./data/source/singleview/object/scan11.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan11.obj",
"extra_info": "Mesh with detailed geometry"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan11.jpg </file_path>
<extra_info> Constraints: [output_format: obj, features:... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan11.jpg', output_path='./outputs/scan11.obj', model='hunyuan') | 128 | Make 3D from {input_file_path}. | Load image and reconstruct it into 3D asset. Focus on certain features. Save the output to a file. The result should be saved in a location. | Process the single-view image located at ./data/source/singleview/object/scan11.obj to create a 3D representation. Save the output as a obj file. It should be a mesh with detailed geometry. Save the output to ./outputs/scan11.obj. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. Expect slow speed processing. Save the output as a glb file. Store the result at ./outputs/scan11.glb. | ./data/source/singleview/object/scan11.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Slow speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan11.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan11.jpg </file_path>
<extra_info> Constraints: [speed: Slow speed, output_for... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan11.jpg', output_path='./outputs/scan11.glb', model='hunyuan') | 129 | Do something with {input_file_path}. | Reconstruct a 3D asset from the image. The generation speed should be specified. Export format: 3D model. Save the output to somewhere. | Process the single-view image located at ./data/source/singleview/object/scan11.stl to create a 3D representation. Expect slow speed processing. Save the output as a glb file. Store the result at ./outputs/scan11.glb. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. The model quality should be ultra-high quality. Save the output as a obj file. The result should be saved in ./outputs/scan11.obj. | ./data/source/singleview/object/scan11.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Ultra-High quality",
"speed": null,
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan11.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan11.jpg </file_path>
<extra_info> Constraints: [quality: Ultra-High quality, output_format: obj]; Output Pa... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan11.jpg', output_path='./outputs/scan11.obj', model='hunyuan') | 130 | Make 3D from {input_file_path}. | Process the single-view image to create a 3D representation. Ensure the result quality is defined. I need a file. Store the generated model. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan11.obj. The model quality should be ultra-high quality. Save the output as a obj file. The result should be saved in ./outputs/scan11.obj. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. Ensure the mesh is high quality. Export format: glb. The result should be saved in ./outputs/scan11.glb. | ./data/source/singleview/object/scan11.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": null,
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan11.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan11.jpg </file_path>
<extra_info> Constraints: [quality: High quality, output_format: glb]; Output Path: ./... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan11.jpg', output_path='./outputs/scan11.glb', model='trellis') | 131 | Do something with {input_file_path}. | Reconstruct a 3D asset from the image. Ensure the result quality is defined. Save the output to a file. Save the output to somewhere. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan11.obj. Ensure the mesh is high quality. Export format: glb. The result should be saved in ./outputs/scan11.glb. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. I need it processed with medium speed. I need a glb file. Ensure high-fidelity mesh. The result should be saved in ./outputs/scan11.glb. | ./data/source/singleview/object/scan11.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Medium speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan11.glb",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan11.jpg </file_path>
<extra_info> Constraints: [speed: Medium speed, output_format: glb, featur... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan11.jpg', output_path='./outputs/scan11.glb', model='trellis') | 132 | Do something with {input_file_path}. | Load image and reconstruct it into 3D asset. The generation speed should be specified. It should have specific attributes. I need a file. The result should be saved in a location. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan11.ply as input. I need it processed with medium speed. I need a glb file. Ensure high-fidelity mesh. The result should be saved in ./outputs/scan11.glb. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. Expect medium speed processing. I need a glb file. Store the result at ./outputs/scan11.glb. | ./data/source/singleview/object/scan11.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Medium speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan11.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan11.jpg </file_path>
<extra_info> Constraints: [speed: Medium speed, output_f... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan11.jpg', output_path='./outputs/scan11.glb', model='trellis') | 133 | Process {input_file_path}. | Perform single-view 3D reconstruction. I need it generated at a certain speed. I need a file. The result should be saved in a location. | Process the single-view image located at ./data/source/singleview/object/scan11.stl to create a 3D representation. Expect medium speed processing. I need a glb file. Store the result at ./outputs/scan11.glb. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. Ensure the mesh is medium quality. Save the output as a glb file. The result should be saved in ./outputs/scan11.glb. | ./data/source/singleview/object/scan11.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Medium quality",
"speed": null,
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan11.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan11.jpg </file_path>
<extra_info> Constraints: [quality: Medium quality, output_format: glb]; Output Pat... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan11.jpg', output_path='./outputs/scan11.glb', model='vggt', conf_thres=20.0) | 134 | Do something with {input_file_path}. | Load image and reconstruct it into 3D asset. Ensure the result quality is defined. Export format: 3D model. Save the output to somewhere. | Load image ./data/source/singleview/object/scan11.glb and reconstruct it into 3D asset. Ensure the mesh is medium quality. Save the output as a glb file. The result should be saved in ./outputs/scan11.glb. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. The model quality should be medium quality. Save the output as a ply file. Save the output to ./outputs/scan11.ply. | ./data/source/singleview/object/scan11.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Medium quality",
"speed": null,
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan11.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan11.jpg </file_path>
<extra_info> Constraints: [quality: Medium quality, output_format: ply]; Output Path: ... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan11.jpg', output_path='./outputs/scan11.ply', model='vggt', conf_thres=20.0) | 135 | Make 3D from {input_file_path}. | Load image and reconstruct it into 3D asset. I require a certain quality. Export format: 3D model. Save the output to somewhere. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan11.glb. The model quality should be medium quality. Save the output as a ply file. Save the output to ./outputs/scan11.ply. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. Ensure the mesh is ultra-high quality. The reconstruction speed should be slow speed. Export format: obj. Save the output to ./outputs/scan110.obj. | ./data/source/singleview/object/scan110.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Ultra-High quality",
"speed": "Slow speed",
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan110.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan110.jpg </file_path>
<extra_info> Constraints: [quality: Ultra-High quality, speed: Slow speed, output_for... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan110.jpg', output_path='./outputs/scan110.obj', model='hunyuan') | 136 | Make 3D from {input_file_path}. | Perform single-view 3D reconstruction. Ensure the result quality is defined. I need it generated at a certain speed. I need a file. Save the output to somewhere. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan110.stl. Ensure the mesh is ultra-high quality. The reconstruction speed should be slow speed. Export format: obj. Save the output to ./outputs/scan110.obj. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. I require ultra-high quality output. Expect slow speed processing. The result should be saved in ./outputs/scan110.glb. | ./data/source/singleview/object/scan110.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Ultra-High quality",
"speed": "Slow speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan110.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan110.jpg </file_path>
<extra_info> Constraints: [quality: Ultra-High quality, speed: Slow speed... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan110.jpg', output_path='./outputs/scan110.glb', model='hunyuan') | 137 | Process {input_file_path}. | Perform single-view 3D reconstruction. I require a certain quality. The generation speed should be specified. The result should be saved in a location. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan110.obj as input. I require ultra-high quality output. Expect slow speed processing. The result should be saved in ./outputs/scan110.glb. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. Export format: glb. It should be a mesh with detailed geometry. Save the output to ./outputs/scan110.glb. | ./data/source/singleview/object/scan110.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan110.glb",
"extra_info": "Mesh with detailed geometry"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan110.jpg </file_path>
<extra_info> Constraints: [output_format: glb, features: Mesh with detail... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan110.jpg', output_path='./outputs/scan110.glb', model='hunyuan') | 138 | Make 3D from {input_file_path}. | Perform single-view 3D reconstruction. Focus on certain features. Export format: 3D model. Store the generated model. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan110.ply as input. Export format: glb. It should be a mesh with detailed geometry. Save the output to ./outputs/scan110.glb. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. The reconstruction speed should be medium speed. Focus on high-fidelity mesh. The result should be saved in ./outputs/scan110.ply. | ./data/source/singleview/object/scan110.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Medium speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan110.ply",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan110.jpg </file_path>
<extra_info> Constraints: [speed: Medium speed, features: High-fidelity mesh]; Output... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan110.jpg', output_path='./outputs/scan110.ply', model='trellis') | 139 | Fix {input_file_path} to 3D. | Perform single-view 3D reconstruction. Expect appropriate processing speed. Focus on certain features. Save the output to somewhere. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan110.glb. The reconstruction speed should be medium speed. Focus on high-fidelity mesh. The result should be saved in ./outputs/scan110.ply. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. Ensure the mesh is high quality. I need a ply file. Ensure high-fidelity mesh. Store the result at ./outputs/scan110.ply. | ./data/source/singleview/object/scan110.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": null,
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan110.ply",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan110.jpg </file_path>
<extra_info> Constraints: [quality: High quality, output_format: ply, fea... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan110.jpg', output_path='./outputs/scan110.ply', model='trellis') | 140 | Process {input_file_path}. | Process the single-view image to create a 3D representation. The model quality should be specified. It should have specific attributes. I need a file. Save the output to somewhere. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan110.obj as input. Ensure the mesh is high quality. I need a ply file. Ensure high-fidelity mesh. Store the result at ./outputs/scan110.ply. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. Expect medium speed processing. Export format: ply. Store the result at ./outputs/scan110.ply. | ./data/source/singleview/object/scan110.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Medium speed",
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan110.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan110.jpg </file_path>
<extra_info> Constraints: [speed: Medium speed, output_format: ply]; Outp... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan110.jpg', output_path='./outputs/scan110.ply', model='trellis') | 141 | Make 3D from {input_file_path}. | Process the single-view image to create a 3D representation. The generation speed should be specified. Export format: 3D model. Store the generated model. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan110.obj as input. Expect medium speed processing. Export format: ply. Store the result at ./outputs/scan110.ply. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. Ensure dense point cloud. The result should be saved in ./outputs/scan110.glb. | ./data/source/singleview/object/scan110.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan110.glb",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan110.jpg </file_path>
<extra_info> Constraints: [features: Dense point cloud]... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan110.jpg', output_path='./outputs/scan110.glb', model='vggt', conf_thres=20.0) | 142 | Make 3D from {input_file_path}. | Perform single-view 3D reconstruction. Consider that this has particular characteristics. Store the generated model. | Process the single-view image located at ./data/source/singleview/object/scan110.ply to create a 3D representation. Ensure dense point cloud. The result should be saved in ./outputs/scan110.glb. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. I need it processed with fast speed. I need a glb file. Ensure dense point cloud. Store the result at ./outputs/scan110.glb. | ./data/source/singleview/object/scan110.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Fast speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan110.glb",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan110.jpg </file_path>
<extra_info> Constraints: [speed: Fast speed, output_format: glb, features: Dense poi... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan110.jpg', output_path='./outputs/scan110.glb', model='vggt', conf_thres=20.0) | 143 | Fix {input_file_path} to 3D. | Load image and reconstruct it into 3D asset. The generation speed should be specified. Focus on certain features. Export format: 3D model. Store the generated model. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan110.stl. I need it processed with fast speed. I need a glb file. Ensure dense point cloud. Store the result at ./outputs/scan110.glb. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. I need it processed with slow speed. Export format: obj. Focus on mesh with detailed geometry. The result should be saved in ./outputs/scan114.obj. | ./data/source/singleview/object/scan114.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Slow speed",
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan114.obj",
"extra_info": "Mesh with detailed geometry"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan114.jpg </file_path>
<extra_info> Constraints: [speed: Slow speed, output_format: obj, features: Mesh with... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan114.jpg', output_path='./outputs/scan114.obj', model='hunyuan') | 144 | Process {input_file_path}. | Reconstruct a 3D asset from the image. Expect appropriate processing speed. It should have specific attributes. Export format: 3D model. Save the output to somewhere. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan114.stl. I need it processed with slow speed. Export format: obj. Focus on mesh with detailed geometry. The result should be saved in ./outputs/scan114.obj. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. I require ultra-high quality output. Expect slow speed processing. Save the output to ./outputs/scan114.obj. | ./data/source/singleview/object/scan114.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Ultra-High quality",
"speed": "Slow speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan114.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan114.jpg </file_path>
<extra_info> Constraints: [quality: Ultra-High quality,... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan114.jpg', output_path='./outputs/scan114.obj', model='hunyuan') | 145 | Fix {input_file_path} to 3D. | Perform single-view 3D reconstruction. I require a certain quality. I need it generated at a certain speed. Store the generated model. | Process the single-view image located at ./data/source/singleview/object/scan114.stl to create a 3D representation. I require ultra-high quality output. Expect slow speed processing. Save the output to ./outputs/scan114.obj. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. I require ultra-high quality output. The reconstruction speed should be slow speed. I need a obj file. The result should be saved in ./outputs/scan114.obj. | ./data/source/singleview/object/scan114.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Ultra-High quality",
"speed": "Slow speed",
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan114.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan114.jpg </file_path>
<extra_info> Constraints: [quality: Ultra-High quality, speed: Slow speed, output_... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan114.jpg', output_path='./outputs/scan114.obj', model='hunyuan') | 146 | Process {input_file_path}. | Process the single-view image to create a 3D representation. I require a certain quality. The generation speed should be specified. Export format: 3D model. Store the generated model. | Load image ./data/source/singleview/object/scan114.stl and reconstruct it into 3D asset. I require ultra-high quality output. The reconstruction speed should be slow speed. I need a obj file. The result should be saved in ./outputs/scan114.obj. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. Focus on high-fidelity mesh. Store the result at ./outputs/scan114.obj. | ./data/source/singleview/object/scan114.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan114.obj",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan114.jpg </file_path>
<extra_info> Constraints: [features: High-fidelity mesh]; Output Path: ./... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan114.jpg', output_path='./outputs/scan114.obj', model='trellis') | 147 | Process {input_file_path}. | Load image and reconstruct it into 3D asset. Focus on certain features. Store the generated model. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan114.glb as input. Focus on high-fidelity mesh. Store the result at ./outputs/scan114.obj. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. Ensure the mesh is high quality. Expect medium speed processing. I need a glb file. Save the output to ./outputs/scan114.glb. | ./data/source/singleview/object/scan114.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": "Medium speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan114.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan114.jpg </file_path>
<extra_info> Constraints: [quality: High quality, speed: Medium speed, output_form... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan114.jpg', output_path='./outputs/scan114.glb', model='trellis') | 148 | Do something with {input_file_path}. | Perform single-view 3D reconstruction. Ensure the result quality is defined. Expect appropriate processing speed. Export format: 3D model. The result should be saved in a location. | Load image ./data/source/singleview/object/scan114.obj and reconstruct it into 3D asset. Ensure the mesh is high quality. Expect medium speed processing. I need a glb file. Save the output to ./outputs/scan114.glb. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. The reconstruction speed should be medium speed. I need a obj file. Save the output to ./outputs/scan114.obj. | ./data/source/singleview/object/scan114.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Medium speed",
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan114.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan114.jpg </file_path>
<extra_info> Constraints: [speed: Medium speed, output_format: obj]; Outp... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan114.jpg', output_path='./outputs/scan114.obj', model='trellis') | 149 | Make 3D from {input_file_path}. | Process the single-view image to create a 3D representation. I need it generated at a certain speed. Save the output to a file. The result should be saved in a location. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan114.obj as input. The reconstruction speed should be medium speed. I need a obj file. Save the output to ./outputs/scan114.obj. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. I require medium quality output. I need a ply file. Set the confidence threshold to 18. The result should be saved in ./outputs/scan114.ply. | ./data/source/singleview/object/scan114.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Medium quality",
"speed": null,
"conf_thres": 18,
"output_format": "ply",
"output_path": "./outputs/scan114.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan114.jpg </file_path>
<extra_info> Constraints: [quality: Medium quality, output_format: ply, conf_thres... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan114.jpg', output_path='./outputs/scan114.ply', model='vggt', conf_thres=18) | 150 | Make 3D from {input_file_path}. | Reconstruct a 3D asset from the image. I require a certain quality. Use a confidence cutoff of a value. I need a file. The result should be saved in a location. | Load image {input_file_path} and reconstruct it into 3D asset. I require medium quality output. I need a ply file. Set the confidence threshold to 1800. The result should be saved in ./outputs/scan114.ply. | parameter |
Perform single-view 3D reconstruction using {input_file_path} as input. Expect fast speed processing. Filter out points with confidence below 17. Save the output to ./outputs/scan114.ply. | ./data/source/singleview/object/scan114.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Fast speed",
"conf_thres": 17,
"output_format": null,
"output_path": "./outputs/scan114.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan114.jpg </file_path>
<extra_info> Constraints: [speed: Fast speed, conf_thres: 17]; Output Pat... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan114.jpg', output_path='./outputs/scan114.ply', model='vggt', conf_thres=17) | 151 | Do something with {input_file_path}. | Reconstruct a 3D asset from the image. The generation speed should be specified. Use a confidence cutoff of a value. Store the generated model. | Perform single-view 3D reconstruction using {input_file_path} as input. Expect fast speed processing. Filter out points with confidence below 1700. Save the output to ./outputs/scan114.ply. | parameter |
Load image {input_file_path} and reconstruct it into 3D asset. It should be a mesh with detailed geometry. Save the output to ./outputs/scan118.glb. | ./data/source/singleview/object/scan118.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan118.glb",
"extra_info": "Mesh with detailed geometry"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan118.jpg </file_path>
<extra_info> Constraints: [features: Mesh with detailed geometry]; Output Path: ./... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan118.jpg', output_path='./outputs/scan118.glb', model='hunyuan') | 152 | Fix {input_file_path} to 3D. | Process the single-view image to create a 3D representation. It should have specific attributes. Save the output to somewhere. | Load image ./data/source/singleview/object/scan118.glb and reconstruct it into 3D asset. It should be a mesh with detailed geometry. Save the output to ./outputs/scan118.glb. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. Expect slow speed processing. Store the result at ./outputs/scan118.glb. | ./data/source/singleview/object/scan118.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Slow speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan118.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan118.jpg </file_path>
<extra_info> Constraints: [speed: Slow speed]; Output Path: ./outputs/scan118.glb ... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan118.jpg', output_path='./outputs/scan118.glb', model='hunyuan') | 153 | Do something with {input_file_path}. | Reconstruct a 3D asset from the image. I need it generated at a certain speed. Store the generated model. | Load image ./data/source/singleview/object/scan118.glb and reconstruct it into 3D asset. Expect slow speed processing. Store the result at ./outputs/scan118.glb. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. I need it processed with slow speed. Export format: obj. Store the result at ./outputs/scan118.obj. | ./data/source/singleview/object/scan118.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Slow speed",
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan118.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan118.jpg </file_path>
<extra_info> Constraints: [speed: Slow speed, output_fo... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan118.jpg', output_path='./outputs/scan118.obj', model='hunyuan') | 154 | Make 3D from {input_file_path}. | Perform single-view 3D reconstruction. The generation speed should be specified. Export format: 3D model. Store the generated model. | Process the single-view image located at ./data/source/singleview/object/scan118.glb to create a 3D representation. I need it processed with slow speed. Export format: obj. Store the result at ./outputs/scan118.obj. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. The reconstruction speed should be medium speed. I need a glb file. Ensure high-fidelity mesh. Save the output to ./outputs/scan118.glb. | ./data/source/singleview/object/scan118.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Medium speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan118.glb",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan118.jpg </file_path>
<extra_info> Constraints: [speed: Medium speed, output_format: glb, features: High... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan118.jpg', output_path='./outputs/scan118.glb', model='trellis') | 155 | Make 3D from {input_file_path}. | Perform single-view 3D reconstruction. I need it generated at a certain speed. It should have specific attributes. Export format: 3D model. Store the generated model. | Load image ./data/source/singleview/object/scan118.stl and reconstruct it into 3D asset. The reconstruction speed should be medium speed. I need a glb file. Ensure high-fidelity mesh. Save the output to ./outputs/scan118.glb. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. Expect medium speed processing. Save the output as a obj file. Store the result at ./outputs/scan118.obj. | ./data/source/singleview/object/scan118.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Medium speed",
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan118.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan118.jpg </file_path>
<extra_info> Constraints: [speed: Medium speed, output_format: obj]; Outp... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan118.jpg', output_path='./outputs/scan118.obj', model='trellis') | 156 | Do something with {input_file_path}. | Reconstruct a 3D asset from the image. I need it generated at a certain speed. Save the output to a file. The result should be saved in a location. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan118.obj as input. Expect medium speed processing. Save the output as a obj file. Store the result at ./outputs/scan118.obj. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. Focus on high-fidelity mesh. Save the output to ./outputs/scan118.ply. | ./data/source/singleview/object/scan118.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan118.ply",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan118.jpg </file_path>
<extra_info> Constraints: [features: High-fidelity mesh... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan118.jpg', output_path='./outputs/scan118.ply', model='trellis') | 157 | Do something with {input_file_path}. | Reconstruct a 3D asset from the image. It should have specific attributes. Save the output to somewhere. | Process the single-view image located at ./data/source/singleview/object/scan118.ply to create a 3D representation. Focus on high-fidelity mesh. Save the output to ./outputs/scan118.ply. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. Save the output as a ply file. Use a confidence cutoff of 28. Save the output to ./outputs/scan118.ply. | ./data/source/singleview/object/scan118.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": 28,
"output_format": "ply",
"output_path": "./outputs/scan118.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan118.jpg </file_path>
<extra_info> Constraints: [output_format: ply, conf_thr... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan118.jpg', output_path='./outputs/scan118.ply', model='vggt', conf_thres=28) | 158 | Do something with {input_file_path}. | Reconstruct a 3D asset from the image. Use a confidence cutoff of a value. Save the output to a file. Save the output to somewhere. | Process the single-view image located at {input_file_path} to create a 3D representation. Save the output as a ply file. Use a confidence cutoff of -28. Save the output to ./outputs/scan118.ply. | parameter |
Reconstruct a 3D asset from the image at {input_file_path}. Ensure the mesh is medium quality. Export format: glb. The result should be saved in ./outputs/scan118.glb. | ./data/source/singleview/object/scan118.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Medium quality",
"speed": null,
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan118.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan118.jpg </file_path>
<extra_info> Constraints: [quality: Medium quality, output_format: glb]; Output Path:... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan118.jpg', output_path='./outputs/scan118.glb', model='vggt', conf_thres=20.0) | 159 | Make 3D from {input_file_path}. | Process the single-view image to create a 3D representation. The model quality should be specified. Save the output to a file. The result should be saved in a location. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan118.glb. Ensure the mesh is medium quality. Export format: glb. The result should be saved in ./outputs/scan118.glb. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. Ensure the mesh is ultra-high quality. The reconstruction speed should be slow speed. I need a obj file. Store the result at ./outputs/scan13.obj. | ./data/source/singleview/object/scan13.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Ultra-High quality",
"speed": "Slow speed",
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan13.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan13.jpg </file_path>
<extra_info> Constraints: [quality: Ultra-High quality, speed: Slow speed, output_f... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan13.jpg', output_path='./outputs/scan13.obj', model='hunyuan') | 160 | Do something with {input_file_path}. | Process the single-view image to create a 3D representation. The model quality should be specified. The generation speed should be specified. Export format: 3D model. The result should be saved in a location. | Load image ./data/source/singleview/object/scan13.stl and reconstruct it into 3D asset. Ensure the mesh is ultra-high quality. The reconstruction speed should be slow speed. I need a obj file. Store the result at ./outputs/scan13.obj. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. I need it processed with slow speed. Export format: glb. Store the result at ./outputs/scan13.glb. | ./data/source/singleview/object/scan13.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Slow speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan13.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan13.jpg </file_path>
<extra_info> Constraints: [speed: Slow speed, output_format: glb]; Output Path: ./outp... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan13.jpg', output_path='./outputs/scan13.glb', model='hunyuan') | 161 | Do something with {input_file_path}. | Reconstruct a 3D asset from the image. Expect appropriate processing speed. Save the output to a file. Store the generated model. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan13.stl. I need it processed with slow speed. Export format: glb. Store the result at ./outputs/scan13.glb. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. I require ultra-high quality output. I need it processed with slow speed. Ensure mesh with detailed geometry. Save the output to ./outputs/scan13.glb. | ./data/source/singleview/object/scan13.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Ultra-High quality",
"speed": "Slow speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan13.glb",
"extra_info": "Mesh with detailed geometry"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan13.jpg </file_path>
<extra_info> Constraints: [quality: Ultra-High quality, speed: Slow speed,... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan13.jpg', output_path='./outputs/scan13.glb', model='hunyuan') | 162 | Fix {input_file_path} to 3D. | Perform single-view 3D reconstruction. I require a certain quality. The generation speed should be specified. Consider that this has particular characteristics. The result should be saved in a location. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan13.obj as input. I require ultra-high quality output. I need it processed with slow speed. Ensure mesh with detailed geometry. Save the output to ./outputs/scan13.glb. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. Ensure the mesh is high quality. I need a obj file. It should be a high-fidelity mesh. The result should be saved in ./outputs/scan13.obj. | ./data/source/singleview/object/scan13.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": null,
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan13.obj",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan13.jpg </file_path>
<extra_info> Constraints: [quality: High quality, output_format: obj, features: Hig... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan13.jpg', output_path='./outputs/scan13.obj', model='trellis') | 163 | Do something with {input_file_path}. | Reconstruct a 3D asset from the image. The model quality should be specified. It should have specific attributes. Save the output to a file. The result should be saved in a location. | Load image ./data/source/singleview/object/scan13.obj and reconstruct it into 3D asset. Ensure the mesh is high quality. I need a obj file. It should be a high-fidelity mesh. The result should be saved in ./outputs/scan13.obj. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. The reconstruction speed should be medium speed. Focus on high-fidelity mesh. Save the output to ./outputs/scan13.ply. | ./data/source/singleview/object/scan13.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Medium speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan13.ply",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan13.jpg </file_path>
<extra_info> Constraints: [speed: Medium speed, features: High-fidelity mesh]; Outp... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan13.jpg', output_path='./outputs/scan13.ply', model='trellis') | 164 | Make 3D from {input_file_path}. | Reconstruct a 3D asset from the image. I need it generated at a certain speed. Consider that this has particular characteristics. The result should be saved in a location. | Load image ./data/source/singleview/object/scan13.glb and reconstruct it into 3D asset. The reconstruction speed should be medium speed. Focus on high-fidelity mesh. Save the output to ./outputs/scan13.ply. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. Ensure the mesh is high quality. Save the output as a obj file. The result should be saved in ./outputs/scan13.obj. | ./data/source/singleview/object/scan13.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": null,
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan13.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan13.jpg </file_path>
<extra_info> Constraints: [quality: High quality, output_format: obj]; Output Path: ./... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan13.jpg', output_path='./outputs/scan13.obj', model='trellis') | 165 | Fix {input_file_path} to 3D. | Load image and reconstruct it into 3D asset. I require a certain quality. I need a file. Save the output to somewhere. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan13.obj. Ensure the mesh is high quality. Save the output as a obj file. The result should be saved in ./outputs/scan13.obj. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. Ensure the mesh is medium quality. I need a ply file. Use a confidence cutoff of 24. Store the result at ./outputs/scan13.ply. | ./data/source/singleview/object/scan13.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Medium quality",
"speed": null,
"conf_thres": 24,
"output_format": "ply",
"output_path": "./outputs/scan13.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan13.jpg </file_path>
<extra_info> Constraints: [quality: Medium quality, output_format: ply, conf_thres:... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan13.jpg', output_path='./outputs/scan13.ply', model='vggt', conf_thres=24) | 166 | Process {input_file_path}. | Reconstruct a 3D asset from the image. Ensure the result quality is defined. Use a confidence cutoff of a value. I need a file. Save the output to somewhere. | Load image {input_file_path} and reconstruct it into 3D asset. Ensure the mesh is medium quality. I need a ply file. Use a confidence cutoff of 2400. Store the result at ./outputs/scan13.ply. | parameter |
Process the single-view image located at {input_file_path} to create a 3D representation. Ensure the mesh is medium quality. Export format: ply. Focus on dense point cloud. Save the output to ./outputs/scan13.ply. | ./data/source/singleview/object/scan13.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Medium quality",
"speed": null,
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan13.ply",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan13.jpg </file_path>
<extra_info> Constraints: [quality: Medium quality, outp... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan13.jpg', output_path='./outputs/scan13.ply', model='vggt', conf_thres=20.0) | 167 | Make 3D from {input_file_path}. | Reconstruct a 3D asset from the image. Ensure the result quality is defined. It should have specific attributes. I need a file. The result should be saved in a location. | Process the single-view image located at ./data/source/singleview/object/scan13.obj to create a 3D representation. Ensure the mesh is medium quality. Export format: ply. Focus on dense point cloud. Save the output to ./outputs/scan13.ply. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. The model quality should be ultra-high quality. It should be a mesh with detailed geometry. Store the result at ./outputs/scan4.glb. | ./data/source/singleview/object/scan4.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Ultra-High quality",
"speed": null,
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan4.glb",
"extra_info": "Mesh with detailed geometry"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan4.jpg </file_path>
<extra_info> Constraints: [quality: Ultra-High quality, f... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan4.jpg', output_path='./outputs/scan4.glb', model='hunyuan') | 168 | Make 3D from {input_file_path}. | Reconstruct a 3D asset from the image. Ensure the result quality is defined. Focus on certain features. Store the generated model. | Process the single-view image located at ./data/source/singleview/object/scan4.glb to create a 3D representation. The model quality should be ultra-high quality. It should be a mesh with detailed geometry. Store the result at ./outputs/scan4.glb. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. Expect slow speed processing. I need a glb file. Store the result at ./outputs/scan4.glb. | ./data/source/singleview/object/scan4.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Slow speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan4.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan4.jpg </file_path>
<extra_info> Constraints: [speed: Slow speed, output_format: glb]; Output Path: ./ou... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan4.jpg', output_path='./outputs/scan4.glb', model='hunyuan') | 169 | Process {input_file_path}. | Load image and reconstruct it into 3D asset. Expect appropriate processing speed. Export format: 3D model. Save the output to somewhere. | Load image ./data/source/singleview/object/scan4.stl and reconstruct it into 3D asset. Expect slow speed processing. I need a glb file. Store the result at ./outputs/scan4.glb. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. Ensure mesh with detailed geometry. Store the result at ./outputs/scan4.glb. | ./data/source/singleview/object/scan4.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan4.glb",
"extra_info": "Mesh with detailed geometry"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan4.jpg </file_path>
<extra_info> Constraints: [features: Mesh with detailed geometry]; Output Path: ./outpu... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan4.jpg', output_path='./outputs/scan4.glb', model='hunyuan') | 170 | Make 3D from {input_file_path}. | Perform single-view 3D reconstruction. Focus on certain features. Store the generated model. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan4.obj. Ensure mesh with detailed geometry. Store the result at ./outputs/scan4.glb. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. Ensure the mesh is high quality. Save the output as a ply file. Focus on high-fidelity mesh. The result should be saved in ./outputs/scan4.ply. | ./data/source/singleview/object/scan4.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": null,
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan4.ply",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan4.jpg </file_path>
<extra_info> Constraints: [quality: High quality, output_format: ply, featu... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan4.jpg', output_path='./outputs/scan4.ply', model='trellis') | 171 | Process {input_file_path}. | Load image and reconstruct it into 3D asset. The model quality should be specified. It should have specific attributes. Export format: 3D model. The result should be saved in a location. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan4.ply as input. Ensure the mesh is high quality. Save the output as a ply file. Focus on high-fidelity mesh. The result should be saved in ./outputs/scan4.ply. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. I require high quality output. I need a obj file. Ensure high-fidelity mesh. Save the output to ./outputs/scan4.obj. | ./data/source/singleview/object/scan4.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": null,
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan4.obj",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan4.jpg </file_path>
<extra_info> Constraints: [quality: High quality, output_format: obj, featu... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan4.jpg', output_path='./outputs/scan4.obj', model='trellis') | 172 | Process {input_file_path}. | Load image and reconstruct it into 3D asset. Ensure the result quality is defined. Focus on certain features. Export format: 3D model. Save the output to somewhere. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan4.stl as input. I require high quality output. I need a obj file. Ensure high-fidelity mesh. Save the output to ./outputs/scan4.obj. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. The model quality should be high quality. Save the output as a obj file. The result should be saved in ./outputs/scan4.obj. | ./data/source/singleview/object/scan4.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": null,
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan4.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan4.jpg </file_path>
<extra_info> Constraints: [quality: High quality, output_... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan4.jpg', output_path='./outputs/scan4.obj', model='trellis') | 173 | Make 3D from {input_file_path}. | Perform single-view 3D reconstruction. Ensure the result quality is defined. I need a file. Store the generated model. | Process the single-view image located at ./data/source/singleview/object/scan4.stl to create a 3D representation. The model quality should be high quality. Save the output as a obj file. The result should be saved in ./outputs/scan4.obj. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. I need a glb file. Focus on dense point cloud. The result should be saved in ./outputs/scan4.glb. | ./data/source/singleview/object/scan4.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan4.glb",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan4.jpg </file_path>
<extra_info> Constraints: [output_format: glb, features: Dense point cloud]; Output ... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan4.jpg', output_path='./outputs/scan4.glb', model='vggt', conf_thres=20.0) | 174 | Do something with {input_file_path}. | Load image and reconstruct it into 3D asset. It should have specific attributes. I need a file. The result should be saved in a location. | Load image ./data/source/singleview/object/scan4.glb and reconstruct it into 3D asset. I need a glb file. Focus on dense point cloud. The result should be saved in ./outputs/scan4.glb. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. Expect fast speed processing. Save the output as a glb file. Save the output to ./outputs/scan4.glb. | ./data/source/singleview/object/scan4.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Fast speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan4.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan4.jpg </file_path>
<extra_info> Constraints: [speed: Fast speed, output_format: glb]; Output Path: ./outpu... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan4.jpg', output_path='./outputs/scan4.glb', model='vggt', conf_thres=20.0) | 175 | Do something with {input_file_path}. | Perform single-view 3D reconstruction. I need it generated at a certain speed. Save the output to a file. Save the output to somewhere. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan4.ply. Expect fast speed processing. Save the output as a glb file. Save the output to ./outputs/scan4.glb. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. I require ultra-high quality output. I need it processed with slow speed. Ensure mesh with detailed geometry. Store the result at ./outputs/scan48.glb. | ./data/source/singleview/object/scan48.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Ultra-High quality",
"speed": "Slow speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan48.glb",
"extra_info": "Mesh with detailed geometry"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan48.jpg </file_path>
<extra_info> Constraints: [quality: Ultra-High quality, speed: Slow speed,... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan48.jpg', output_path='./outputs/scan48.glb', model='hunyuan') | 176 | Process {input_file_path}. | Perform single-view 3D reconstruction. I require a certain quality. The generation speed should be specified. It should have specific attributes. The result should be saved in a location. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan48.ply as input. I require ultra-high quality output. I need it processed with slow speed. Ensure mesh with detailed geometry. Store the result at ./outputs/scan48.glb. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. The model quality should be ultra-high quality. Expect slow speed processing. I need a obj file. The result should be saved in ./outputs/scan48.obj. | ./data/source/singleview/object/scan48.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Ultra-High quality",
"speed": "Slow speed",
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan48.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan48.jpg </file_path>
<extra_info> Constraints: [quality: Ultra-High quality, speed: Slow speed, output_f... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan48.jpg', output_path='./outputs/scan48.obj', model='hunyuan') | 177 | Fix {input_file_path} to 3D. | Load image and reconstruct it into 3D asset. I require a certain quality. The generation speed should be specified. Export format: 3D model. Store the generated model. | Load image ./data/source/singleview/object/scan48.obj and reconstruct it into 3D asset. The model quality should be ultra-high quality. Expect slow speed processing. I need a obj file. The result should be saved in ./outputs/scan48.obj. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. The reconstruction speed should be slow speed. Export format: glb. Store the result at ./outputs/scan48.glb. | ./data/source/singleview/object/scan48.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Slow speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan48.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan48.jpg </file_path>
<extra_info> Constraints: [speed: Slow speed, output_for... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan48.jpg', output_path='./outputs/scan48.glb', model='hunyuan') | 178 | Process {input_file_path}. | Process the single-view image to create a 3D representation. I need it generated at a certain speed. Save the output to a file. Store the generated model. | Process the single-view image located at ./data/source/singleview/object/scan48.obj to create a 3D representation. The reconstruction speed should be slow speed. Export format: glb. Store the result at ./outputs/scan48.glb. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. I require high quality output. I need a obj file. Focus on high-fidelity mesh. The result should be saved in ./outputs/scan48.obj. | ./data/source/singleview/object/scan48.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": null,
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan48.obj",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan48.jpg </file_path>
<extra_info> Constraints: [quality: High quality, output... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan48.jpg', output_path='./outputs/scan48.obj', model='trellis') | 179 | Process {input_file_path}. | Perform single-view 3D reconstruction. I require a certain quality. It should have specific attributes. I need a file. The result should be saved in a location. | Process the single-view image located at ./data/source/singleview/object/scan48.stl to create a 3D representation. I require high quality output. I need a obj file. Focus on high-fidelity mesh. The result should be saved in ./outputs/scan48.obj. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. The reconstruction speed should be medium speed. I need a ply file. Focus on high-fidelity mesh. The result should be saved in ./outputs/scan48.ply. | ./data/source/singleview/object/scan48.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Medium speed",
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan48.ply",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan48.jpg </file_path>
<extra_info> Constraints: [speed: Medium speed, output_format: ply, features: High-... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan48.jpg', output_path='./outputs/scan48.ply', model='trellis') | 180 | Process {input_file_path}. | Perform single-view 3D reconstruction. Expect appropriate processing speed. Focus on certain features. I need a file. Save the output to somewhere. | Load image ./data/source/singleview/object/scan48.stl and reconstruct it into 3D asset. The reconstruction speed should be medium speed. I need a ply file. Focus on high-fidelity mesh. The result should be saved in ./outputs/scan48.ply. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. The model quality should be high quality. The reconstruction speed should be medium speed. I need a glb file. The result should be saved in ./outputs/scan48.glb. | ./data/source/singleview/object/scan48.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": "Medium speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan48.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan48.jpg </file_path>
<extra_info> Constraints: [quality: High quality, speed:... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan48.jpg', output_path='./outputs/scan48.glb', model='trellis') | 181 | Do something with {input_file_path}. | Reconstruct a 3D asset from the image. The model quality should be specified. Expect appropriate processing speed. Export format: 3D model. Store the generated model. | Process the single-view image located at ./data/source/singleview/object/scan48.obj to create a 3D representation. The model quality should be high quality. The reconstruction speed should be medium speed. I need a glb file. The result should be saved in ./outputs/scan48.glb. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. I need a ply file. Set the confidence threshold to 27. Store the result at ./outputs/scan48.ply. | ./data/source/singleview/object/scan48.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": 27,
"output_format": "ply",
"output_path": "./outputs/scan48.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan48.jpg </file_path>
<extra_info> Constraints: [output_format: ply, conf_thre... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan48.jpg', output_path='./outputs/scan48.ply', model='vggt', conf_thres=27) | 182 | Do something with {input_file_path}. | Process the single-view image to create a 3D representation. Use a confidence cutoff of a value. Export format: 3D model. The result should be saved in a location. | Process the single-view image located at {input_file_path} to create a 3D representation. I need a ply file. Set the confidence threshold to -27. Store the result at ./outputs/scan48.ply. | parameter |
Reconstruct a 3D asset from the image at {input_file_path}. I require medium quality output. I need it processed with fast speed. It should be a dense point cloud. The result should be saved in ./outputs/scan48.ply. | ./data/source/singleview/object/scan48.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Medium quality",
"speed": "Fast speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan48.ply",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan48.jpg </file_path>
<extra_info> Constraints: [quality: Medium quality, speed: Fast speed, features: Dense... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan48.jpg', output_path='./outputs/scan48.ply', model='vggt', conf_thres=20.0) | 183 | Do something with {input_file_path}. | Load image and reconstruct it into 3D asset. I require a certain quality. The generation speed should be specified. Focus on certain features. Store the generated model. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan48.stl. I require medium quality output. I need it processed with fast speed. It should be a dense point cloud. The result should be saved in ./outputs/scan48.ply. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. Expect slow speed processing. Store the result at ./outputs/scan62.glb. | ./data/source/singleview/object/scan62.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Slow speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan62.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan62.jpg </file_path>
<extra_info> Constraints: [speed: Slow speed]; Output Pa... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan62.jpg', output_path='./outputs/scan62.glb', model='hunyuan') | 184 | Process {input_file_path}. | Process the single-view image to create a 3D representation. I need it generated at a certain speed. The result should be saved in a location. | Process the single-view image located at ./data/source/singleview/object/scan62.ply to create a 3D representation. Expect slow speed processing. Store the result at ./outputs/scan62.glb. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. I need it processed with slow speed. Export format: obj. Save the output to ./outputs/scan62.obj. | ./data/source/singleview/object/scan62.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Slow speed",
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan62.obj",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan62.jpg </file_path>
<extra_info> Constraints: [speed: Slow speed, output_format: obj]; Output Path: ./o... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan62.jpg', output_path='./outputs/scan62.obj', model='hunyuan') | 185 | Fix {input_file_path} to 3D. | Process the single-view image to create a 3D representation. I need it generated at a certain speed. I need a file. The result should be saved in a location. | Load image ./data/source/singleview/object/scan62.ply and reconstruct it into 3D asset. I need it processed with slow speed. Export format: obj. Save the output to ./outputs/scan62.obj. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. I need it processed with slow speed. I need a glb file. It should be a mesh with detailed geometry. Store the result at ./outputs/scan62.glb. | ./data/source/singleview/object/scan62.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Slow speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan62.glb",
"extra_info": "Mesh with detailed geometry"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan62.jpg </file_path>
<extra_info> Constraints: [speed: Slow speed, output_for... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan62.jpg', output_path='./outputs/scan62.glb', model='hunyuan') | 186 | Do something with {input_file_path}. | Perform single-view 3D reconstruction. I need it generated at a certain speed. Consider that this has particular characteristics. I need a file. Store the generated model. | Process the single-view image located at ./data/source/singleview/object/scan62.stl to create a 3D representation. I need it processed with slow speed. I need a glb file. It should be a mesh with detailed geometry. Store the result at ./outputs/scan62.glb. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. I need it processed with medium speed. Export format: glb. Store the result at ./outputs/scan62.glb. | ./data/source/singleview/object/scan62.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Medium speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan62.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan62.jpg </file_path>
<extra_info> Constraints: [speed: Medium speed, output_format: glb]; Output Path: ./ou... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan62.jpg', output_path='./outputs/scan62.glb', model='trellis') | 187 | Make 3D from {input_file_path}. | Load image and reconstruct it into 3D asset. Expect appropriate processing speed. I need a file. Store the generated model. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan62.obj. I need it processed with medium speed. Export format: glb. Store the result at ./outputs/scan62.glb. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. I need a ply file. Focus on high-fidelity mesh. Store the result at ./outputs/scan62.ply. | ./data/source/singleview/object/scan62.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan62.ply",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan62.jpg </file_path>
<extra_info> Constraints: [output_format: ply, features: High-fidelity mesh]; Output P... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan62.jpg', output_path='./outputs/scan62.ply', model='trellis') | 188 | Make 3D from {input_file_path}. | Perform single-view 3D reconstruction. Consider that this has particular characteristics. Export format: 3D model. Store the generated model. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan62.stl. I need a ply file. Focus on high-fidelity mesh. Store the result at ./outputs/scan62.ply. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. Expect medium speed processing. I need a ply file. Store the result at ./outputs/scan62.ply. | ./data/source/singleview/object/scan62.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Medium speed",
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan62.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan62.jpg </file_path>
<extra_info> Constraints: [speed: Medium speed, output_format: ply]; Output Path: .... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan62.jpg', output_path='./outputs/scan62.ply', model='trellis') | 189 | Make 3D from {input_file_path}. | Perform single-view 3D reconstruction. I need it generated at a certain speed. Save the output to a file. Save the output to somewhere. | Load image ./data/source/singleview/object/scan62.ply and reconstruct it into 3D asset. Expect medium speed processing. I need a ply file. Store the result at ./outputs/scan62.ply. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. I require medium quality output. I need it processed with fast speed. Save the output to ./outputs/scan62.glb. | ./data/source/singleview/object/scan62.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Medium quality",
"speed": "Fast speed",
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan62.glb",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan62.jpg </file_path>
<extra_info> Constraints: [quality: Medium quality, speed: Fast speed]; Output Path: .... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan62.jpg', output_path='./outputs/scan62.glb', model='vggt', conf_thres=20.0) | 190 | Process {input_file_path}. | Process the single-view image to create a 3D representation. I require a certain quality. The generation speed should be specified. The result should be saved in a location. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan62.ply. I require medium quality output. I need it processed with fast speed. Save the output to ./outputs/scan62.glb. | input_format |
Load image {input_file_path} and reconstruct it into 3D asset. Export format: ply. Focus on dense point cloud. The result should be saved in ./outputs/scan62.ply. | ./data/source/singleview/object/scan62.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan62.ply",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Load image {input_file_path} and reconstruct it into 3D asset based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan62.jpg </file_path>
<extra_info> Constraints: [output_format: ply, features: Dense point cloud]; Output... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan62.jpg', output_path='./outputs/scan62.ply', model='vggt', conf_thres=20.0) | 191 | Make 3D from {input_file_path}. | Process the single-view image to create a 3D representation. Focus on certain features. Save the output to a file. The result should be saved in a location. | Load image ./data/source/singleview/object/scan62.ply and reconstruct it into 3D asset. Export format: ply. Focus on dense point cloud. The result should be saved in ./outputs/scan62.ply. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. I need it processed with slow speed. I need a glb file. It should be a mesh with detailed geometry. The result should be saved in ./outputs/scan75.glb. | ./data/source/singleview/object/scan75.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Slow speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan75.glb",
"extra_info": "Mesh with detailed geometry"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan75.jpg </file_path>
<extra_info> Constraints: [speed: Slow speed, output_format: glb, features: Mesh with ... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan75.jpg', output_path='./outputs/scan75.glb', model='hunyuan') | 192 | Process {input_file_path}. | Load image and reconstruct it into 3D asset. I need it generated at a certain speed. Consider that this has particular characteristics. I need a file. The result should be saved in a location. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan75.ply. I need it processed with slow speed. I need a glb file. It should be a mesh with detailed geometry. The result should be saved in ./outputs/scan75.glb. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. Export format: obj. Ensure mesh with detailed geometry. Store the result at ./outputs/scan75.obj. | ./data/source/singleview/object/scan75.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan75.obj",
"extra_info": "Mesh with detailed geometry"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan75.jpg </file_path>
<extra_info> Constraints: [output_format: obj, features:... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan75.jpg', output_path='./outputs/scan75.obj', model='hunyuan') | 193 | Make 3D from {input_file_path}. | Perform single-view 3D reconstruction. Focus on certain features. Save the output to a file. Store the generated model. | Process the single-view image located at ./data/source/singleview/object/scan75.obj to create a 3D representation. Export format: obj. Ensure mesh with detailed geometry. Store the result at ./outputs/scan75.obj. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. Ensure the mesh is ultra-high quality. It should be a mesh with detailed geometry. The result should be saved in ./outputs/scan75.glb. | ./data/source/singleview/object/scan75.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "Ultra-High quality",
"speed": null,
"conf_thres": null,
"output_format": null,
"output_path": "./outputs/scan75.glb",
"extra_info": "Mesh with detailed geometry"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan75.jpg </file_path>
<extra_info> Constraints: [quality: Ultra-High quality, ... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan75.jpg', output_path='./outputs/scan75.glb', model='hunyuan') | 194 | Fix {input_file_path} to 3D. | Process the single-view image to create a 3D representation. I require a certain quality. Focus on certain features. Store the generated model. | Process the single-view image located at ./data/source/singleview/object/scan75.ply to create a 3D representation. Ensure the mesh is ultra-high quality. It should be a mesh with detailed geometry. The result should be saved in ./outputs/scan75.glb. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. I require high quality output. Save the output as a obj file. Ensure high-fidelity mesh. Store the result at ./outputs/scan75.obj. | ./data/source/singleview/object/scan75.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": null,
"conf_thres": null,
"output_format": "obj",
"output_path": "./outputs/scan75.obj",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan75.jpg </file_path>
<extra_info> Constraints: [quality: High quality, output_format: obj, feat... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan75.jpg', output_path='./outputs/scan75.obj', model='trellis') | 195 | Process {input_file_path}. | Reconstruct a 3D asset from the image. Ensure the result quality is defined. Consider that this has particular characteristics. Save the output to a file. Store the generated model. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan75.obj as input. I require high quality output. Save the output as a obj file. Ensure high-fidelity mesh. Store the result at ./outputs/scan75.obj. | input_format |
Process the single-view image located at {input_file_path} to create a 3D representation. The model quality should be high quality. The reconstruction speed should be medium speed. I need a ply file. The result should be saved in ./outputs/scan75.ply. | ./data/source/singleview/object/scan75.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": "High quality",
"speed": "Medium speed",
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan75.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Process the single-view image located at {input_file_path} to create a 3D representation based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan75.jpg </file_path>
<extra_info> Constraints: [quality: High quality, speed:... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan75.jpg', output_path='./outputs/scan75.ply', model='trellis') | 196 | Make 3D from {input_file_path}. | Reconstruct a 3D asset from the image. The model quality should be specified. Expect appropriate processing speed. Export format: 3D model. The result should be saved in a location. | Process the single-view image located at ./data/source/singleview/object/scan75.stl to create a 3D representation. The model quality should be high quality. The reconstruction speed should be medium speed. I need a ply file. The result should be saved in ./outputs/scan75.ply. | input_format |
Reconstruct a 3D asset from the image at {input_file_path}. Save the output as a ply file. Ensure high-fidelity mesh. The result should be saved in ./outputs/scan75.ply. | ./data/source/singleview/object/scan75.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": null,
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan75.ply",
"extra_info": "High-fidelity mesh"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Reconstruct a 3D asset from the image at {input_file_path} based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan75.jpg </file_path>
<extra_info> Constraints: [output_format: ply, features: High-fidelity mesh]; Output P... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan75.jpg', output_path='./outputs/scan75.ply', model='trellis') | 197 | Do something with {input_file_path}. | Process the single-view image to create a 3D representation. Consider that this has particular characteristics. Export format: 3D model. Save the output to somewhere. | Reconstruct a 3D asset from the image at ./data/source/singleview/object/scan75.stl. Save the output as a ply file. Ensure high-fidelity mesh. The result should be saved in ./outputs/scan75.ply. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. I need it processed with fast speed. Export format: glb. Ensure dense point cloud. Store the result at ./outputs/scan75.glb. | ./data/source/singleview/object/scan75.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Fast speed",
"conf_thres": null,
"output_format": "glb",
"output_path": "./outputs/scan75.glb",
"extra_info": "Dense point cloud"
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan75.jpg </file_path>
<extra_info> Constraints: [speed: Fast speed, output_format: glb, features... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan75.jpg', output_path='./outputs/scan75.glb', model='vggt', conf_thres=20.0) | 198 | Process {input_file_path}. | Reconstruct a 3D asset from the image. Expect appropriate processing speed. It should have specific attributes. Export format: 3D model. Store the generated model. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan75.glb as input. I need it processed with fast speed. Export format: glb. Ensure dense point cloud. Store the result at ./outputs/scan75.glb. | input_format |
Perform single-view 3D reconstruction using {input_file_path} as input. I need it processed with fast speed. Export format: ply. The result should be saved in ./outputs/scan75.ply. | ./data/source/singleview/object/scan75.jpg | [
{
"task": "Single-View 3D Reconstruction",
"usage": "object",
"quality": null,
"speed": "Fast speed",
"conf_thres": null,
"output_format": "ply",
"output_path": "./outputs/scan75.ply",
"extra_info": null
}
] | <task_type> Single-View 3D Reconstruction </task_type>
<task_summary> Perform single-view 3D reconstruction using {input_file_path} as input based on constraints </task_summary>
<file_path> ./data/source/singleview/object/scan75.jpg </file_path>
<extra_info> Constraints: [speed: Fast speed, output_format: ply]; Output ... | self.executor.single_view_reconstruction(image_path='./data/source/singleview/object/scan75.jpg', output_path='./outputs/scan75.ply', model='vggt', conf_thres=20.0) | 199 | Do something with {input_file_path}. | Load image and reconstruct it into 3D asset. I need it generated at a certain speed. Save the output to a file. Save the output to somewhere. | Perform single-view 3D reconstruction using ./data/source/singleview/object/scan75.obj as input. I need it processed with fast speed. Export format: ply. The result should be saved in ./outputs/scan75.ply. | input_format |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.