Method for dynamically calculating scene virtual camera cutting plane based on scene boundary

By automatically calculating the bounding box of geometric bodies in a three-dimensional scene, dynamically adjusting the camera's cropping plane is solved, the problem of manual adjustment is improved, creative efficiency and fluency is improved, and the work burden of technicians is reduced while achieving high picture quality.

CN118941754AInactive Publication Date: 2024-11-12山东捷瑞信息技术产业研究院有限公司

Patent Information

Application Number
CN202411432953.5
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2024-10-15
Publication Date
2024-11-12
Estimated Expiration
Not applicable · inactive patent

AI Technical Summary

Technical Problem

In three-dimensional scene construction, manually adjusting the near and far shear planes of the camera is a fine and time-consuming task, especially when frequent camera dynamic changes and scene content updates, resulting in increased workload and reduced creative efficiency .

Method used

By obtaining all renderable geometry in the scene, calculating its bounding box and combining it into the largest bounding box, automatically adjusting the far crop plane and near crop plane of the camera, dynamically calculate the position of the crop plane based on the maximum and minimum values ​​of the geometry in the scene, and implementing the Automatic adaptability adjustment.

Benefits of technology

It significantly reduces the time and energy investment of technicians in cutting plane adjustment, improves the fluency and efficiency of the three-dimensional creative process, and maintains high picture quality while improving creative design and content optimization capabilities.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN118941754A_ABST
    Figure CN118941754A_ABST
Patent Text Reader

Abstract

The invention relates to a method for dynamically calculating a scene virtual camera cutting plane based on a scene boundary, and belongs to the technical field of computers, and the method comprises the following steps: 1, obtaining all renderable geometries in a scene; 2, calculating bounding boxes of all geometries, combining the bounding boxes into a maximum bounding box, and obtaining a nearest point and a farthest point of the maximum bounding box; 3, calculating the value of the nearest point and the value of the farthest point of the maximum bounding box relative to the camera; 4, defining a far cutting plane multiple and a near cutting plane multiple of the camera; 5, calculating a far cutting plane and a near cutting plane of the camera; and 6, acquiring all cameras of the scene, and setting a far shearing plane and a near shearing plane. According to the invention, by analyzing the change of the scene structure and the observation range of the camera in real time, the cutting plane position which is most suitable for the current state is automatically found, so that high image quality is maintained, the invested time and energy are reduced, and the fluency and efficiency of the whole three-dimensional creation process are improved.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The invention relates to a method for dynamically calculating a scene virtual camera clipping plane based on a scene boundary, and belongs to the technical field of computers. Background Art

[0002] In the development of 3D graphics technology and related software, the camera clipping plane mechanism constitutes an indispensable basic function. This technical principle allows developers to define one or more virtual clipping planes to draw an invisible boundary in 3D space, so as to remove those geometric bodies that are outside the camera's view frustum or exceed the preset clipping range, and realize flexible and real-time 3D content clipping. In this way, only the part of the object that is within the view frustum and not cut off by the clipping plane will be rendered, thereby improving the effectiveness and pertinence of the rendering process.

[0003] The role of the camera clipping plane in 3D modeling and animation production is crucial. It is not only related to the optimization of rendering speed and system performance, but also directly determines the quality and detail expression of the final output image. By accurately defining and adjusting the position of the clipping plane, designers can effectively screen out the objects that need to be rendered, maintain the visual continuity and logic of the scene, and eliminate various visual errors caused by unnecessary object rendering, such as mutual penetration between objects and confusion in depth sorting. In addition, the proper use of clipping plane technology can also simulate the physical properties of cameras in the real world, such as the "near big and far small" effect in perspective relationships and occlusion interactions between different objects, thereby greatly enhancing the realism and immersion of 3D scenes.

[0004] However, in the actual operation of 3D scene construction, manually adjusting the camera's near and far clipping planes is a delicate and time-consuming task. Especially in the face of frequent camera dynamic changes and large-scale updates to scene content, manually configuring the clipping plane distance will undoubtedly increase the workload and reduce creation efficiency. Summary of the invention

[0005] The present invention aims to propose a method for dynamically calculating a scene virtual camera clipping plane based on scene boundaries, so as to reduce the workload of personnel and improve the creation efficiency.

[0006] A method for dynamically calculating a scene virtual camera clipping plane based on a scene boundary, the method comprising the following steps: Step 1: Get all renderable geometries in the scene; Step 2: Calculate the bounding boxes of all geometric bodies, merge them into the maximum bounding box, and obtain the closest and farthest points of the maximum bounding box relative to the camera; Step 3: Calculate the value of the closest point and the farthest point of the maximum bounding box relative to the camera; Step 4: Define the camera's far clipping plane multiples and near clipping plane multiples; Step 5: Calculate the camera's far clipping plane and near clipping plane; Step 6: Get all the cameras in the scene and set the far clipping plane and near clipping plane.

[0007] Furthermore, in step 1, all geometric bodies in the scene are screened and listed through the function cmds.ls and its calling parameters "geometry=True, noIntermediate=True"; the geometric bodies refer to those 3D objects that can be finally rendered, excluding auxiliary objects created in the modeling process.

[0008] Furthermore, in step 2, the bounding boxes of the world space of all the geometric bodies obtained in step 1 are calculated by calling the function bbox=cmds.exactWorldBoundingBox(geometry), and these bounding boxes are merged into a maximum bounding box, and the coordinate vectors of the nearest point and the farthest point of the returned maximum bounding box relative to the camera are assigned to the variable bbox; specifically, the following steps are included: Step 21: Determine the object list geometry that needs to calculate the bounding box. The Geometry list includes all the geometric bodies in the scene; Step 22, calculate the bounding box of each geometric body in the list in the local space, and find the smallest cube that can enclose all vertices in its own coordinate system; Step 23: Convert the local bounds of each geometric object to world space. The specific internal method is to multiply each vertex of the local bounding box by the world transformation matrix of the geometric object, so that the bounding box will be equivalent to the coordinate system of the entire world for system positioning; Step 24: Merge the world space bounding boxes of all geometries into a maximum bounding box. Step 25: The final returned result is the coordinate vector of the closest point and the farthest point of the maximum bounding box in the scene relative to the camera.

[0009] Furthermore, in S3, the maximum size and minimum size of the maximum bounding box relative to the camera are calculated as follows: max_dim=max(maxX-minX,maxY-minY,maxZ-minZ); min_dim=min(maxX-minX,maxY-minY,maxZ-minZ); Among them, max_dim and min_dim are the maximum distance and minimum distance of the maximum bounding box in three dimensions, maxX–minX is the length of the maximum bounding box on the x-axis, maxY–minY is the length of the maximum bounding box on the y-axis, and maxZ–minZ is the length of the maximum bounding box on the z-axis.

[0010] Furthermore, in step 4, the far clipping plane multiple and the near clipping plane multiple of the camera are custom values.

[0011] Furthermore, in step 5: The far clipping plane of the camera is calculated by the function far_clip_value=max_dim*far_clip_multiplier, where far_clip_value is the far clipping plane of the camera, max_dim is the maximum size of the maximum bounding box, and far_clip_multiplier is the multiple of the far clipping plane of the camera; The near clipping plane of the camera is calculated by the function near_clip_value=min_dim*near_clip_multiplier, where near_clip_value is the near clipping plane of the camera, min_dim is the minimum size of the maximum bounding box, and near_clip_multiplier is the multiple of the near clipping plane of the camera.

[0012] Furthermore, in step 6, a for loop is used to traverse all cameras in the scene, and the far clipping plane and near clipping plane of the camera obtained in step 5 are assigned to each camera, thereby finally realizing dynamic calculation of the camera clipping plane.

[0013] The present invention provides a method for dynamically calculating the scene virtual camera clipping plane based on the scene boundary, which automatically and adaptively adjusts the distance between the camera's minimum clipping plane (i.e., near clipping plane) and maximum clipping plane (i.e., far clipping plane) according to the maximum and minimum values ​​of the geometric body boundary in the scene. It overcomes the limitations of the traditional manual adjustment method, and automatically finds the most suitable clipping plane position in the current state by analyzing the changes in the scene structure and the camera's observation range in real time, thereby significantly reducing the time and energy invested by technicians in this link while maintaining high image quality, allowing them to focus more on creative design and content optimization, and improving the fluency and efficiency of the entire three-dimensional creation process. BRIEF DESCRIPTION OF THE DRAWINGS

[0014] Figure 1 : Flowchart of a method for dynamically calculating a scene virtual camera clipping plane based on scene boundaries in Example 1. DETAILED DESCRIPTION

[0015] The present invention will be described in detail below with reference to the accompanying drawings.

[0016] Some related technical descriptions related to this embodiment: Python is a general-purpose, high-level programming language that is designed to have an easy-to-read and easy-to-write syntax and to support multiple programming paradigms, including object-oriented, imperative, functional, and procedural programming.

[0017] Python API refers to the interface that allows Python programs to interact with other software applications. API defines a set of rules and protocols that allow one application to request services or data from another application. In Python application software, APIs are provided in the form of libraries or modules, which contain a set of functions, classes, and methods for developers to use.

[0018] The method of dynamically calculating the scene virtual camera clipping plane based on the scene boundary involved in this embodiment is essentially a specific API of the application software. This API provides a series of functions and objects, allowing developers to create, query, and modify objects and attributes in the scene, as well as perform other software-related operations and tasks. In summary, Python is a programming language, and Python API refers to a specific software interface provided for Python, which enables Python programs to interact with the software. Different Python APIs allow developers to use Python scripts to automate the workflow of the software. This method can be simply understood. This method uses the functions and objects provided by the API to perform certain logical combinations, obtain some related parameters, and drive the automatic change of the camera plane. It is different from the command execution in software operation. It is not easy to master, nor is it a specific operation command. It requires the creator's own ideas and methods, such as the selection of functions, the addition of restrictions, and what kind of data or parameters to obtain. It has its own operating logic and judgment method.

[0019] Explanation and principle of bounding box: In the operating software, each combination has a bounding box, which is an imaginary box whose boundaries just surround the entire geometric body. In this way, this bounding box helps us quickly determine the position and size of the object in 3D space. It will change the size of the bounding box with the properties of the object, that is, the same object will have different bounding boxes in different states. For example, the size and direction will change according to the rotation, scaling, and merging of the object. The bounding box of the longest object can contain the bounding box of the small object within the range; the bounding box of the widest object can contain the bounding box of the small object within the range; the bounding box of the tallest object can contain the bounding box of the small object within the range; for three or more objects with different lengths, widths, and heights, a maximum bounding box will be calculated by default.

[0020] The present embodiment provides a method for dynamically calculating a scene virtual camera clipping plane based on a scene boundary, the process is as follows: Figure 1 As shown, the specific steps include: Step 1: Get all renderable geometry in the scene Through the function cmds.ls and its calling parameters "geometry=True,noIntermediate=True", all the geometric bodies in the scene are filtered to form an object list called geometry. The code is: geometry=cmds.ls(geometry=True,noIntermediate=True).

[0021] The cmd.ls function can list various object types in the scene, including geometry, lights, cameras, etc. It can accept multiple parameters to filter and customize the returned object list. Here, it uses certain attributes and restriction types to filter and list the required type of geometry: The parameter "geometry=True" tells cmd.ls to only list the geometry in the scene. The geometry here refers to those 3D objects that can be rendered in the end, such as polygonal objects, surfaces, etc. The parameter "noIntermediate=True" tells cmd.ls not to list intermediate objects. The intermediate objects here refer to auxiliary objects created during the modeling process, which usually do not appear in the final rendering.

[0022] Step 2: Calculate the bounding boxes of all geometric bodies, merge them into the maximum bounding box, and obtain the closest and farthest points of the maximum bounding box relative to the camera; The function bbox=cmds.exactWorldBoundingBox(geometry) is used to calculate the bounding boxes of all geometries in the object list geometry obtained in step 1, and these bounding boxes are merged into a maximum bounding box that can enclose all geometries. Finally, the coordinate vectors of the nearest and farthest points of the maximum bounding box relative to the camera are returned and assigned to the variable bbox. The specific steps are as follows: Step 21, determine the object, determine the object for which the bounding box needs to be calculated, which can be a geometric body or a list of multiple objects; the object list geometry in this embodiment includes all the geometric bodies in the scene obtained in step 1; Step 22: Calculate the local bounding box. First, calculate the bounding box of the geometric body in the local space, and find the smallest cube that can enclose all vertices in the geometric body's own coordinate system. Step 23: Convert to world space. Convert the local bounds of each geometric body to world space. The specific internal method is to multiply each vertex of the local bounding box by the world transformation matrix of the geometric body, so that the bounding box will be equivalent to the coordinate system of the entire world for system positioning. Step 24: Merge bounding boxes to merge the world space bounding boxes of all geometric bodies into a maximum bounding box that can enclose all geometric bodies. Step 25. The final return result is a list of 6 floating-point numbers [minX, minY, minZ, maxX, maxY, maxZ], which define the closest and farthest points of the maximum bounding box from the camera. [minX, minY, minZ] represent the X, Y, and Z coordinates of the closest point of the maximum bounding box to the camera, and [maxX, maxY, maxZ] represent the X, Y, and Z coordinates of the farthest point of the maximum bounding box from the camera.

[0023] Step 3: Calculate the value of the closest point and the farthest point of the maximum bounding box relative to the camera Based on the maximum bounding box information obtained in step 2, calculate the maximum distance and minimum distance of the maximum bounding box in the three dimensions of XYZ. Specifically, calculate the length of the maximum bounding box on the x-axis, y-axis, and z-axis, and find the maximum and minimum values ​​of these three lengths. The algorithm is as follows: max_dim=max(maxX-minX,maxY-minY,maxZ-minZ); min_dim=min(maxX-minX,maxY-minY,maxZ-minZ); Calculation principle: Use the max() and min() functions to compare the three lengths and find the maximum and minimum values; Calculation formula: max_dim is the maximum distance of the maximum bounding box in three dimensions, calculated as: max_dim=max(width,height,depth); min_dim is the minimum distance of the maximum bounding box in three dimensions, calculated as: min_dim=min(width,height,depth); The specific calculation process is as follows: 1. Calculate the length of the maximum bounding box on the x-axis through max_dim=max(maxX-minX,maxY-minY,maxZ-minZ): maxX–minX; then calculate the length of the maximum bounding box on the y-axis: maxY–minY; then calculate the length of the maximum bounding box on the z-axis: maxZ–minZ; finally, the general max() function compares these three lengths and finds the maximum value from them, and assigns this maximum value to the variable max_dim, that is, max_dim stores the maximum distance of the maximum bounding box in three dimensions.

[0024] 2. Calculate the length of the maximum bounding box on the x-axis through min_dim=min(maxX-minX,maxY-minY,maxZ-minZ): maxX–minX; then calculate the length of the bounding box on the y-axis: maxY–minY; then calculate the length of the bounding box on the z-axis: maxZ–minZ; finally, compare these three lengths through the minx() function, find the largest one, and assign this maximum value to the variable min_dim, that is, min_dim stores the minimum distance of the maximum bounding box in three dimensions.

[0025] Step 4: Define the camera's far clipping plane multiplier and near clipping plane multiplier far_clip_multiplier=100 near_clip_multiplier=0.01 Overall principle: In 3D graphics, the camera has a frustum that defines the space of the scene that the camera can see. Two important parameters of the frustum are the far clipping plane and the near clipping plane. Any object outside the far clipping plane will not be rendered, and any object inside the near clipping plane will not be rendered. The space between these two planes is the area visible to the camera and is called the viewing volume.

[0026] 1. Define the variable far_clip_multiplier, which is used to calculate the camera's far clipping plane multiplier. The far clipping plane is the far end of the viewing cone and determines the farthest distance the camera can see. In this embodiment, far_clip_multiplier is set to 100, which means that the far clipping plane may be a value based on the scene size multiplied by 100. For example, if the maximum size of the scene is 10 units, then the far clipping plane may be 1000 units.

[0027] 2. Define the variable near_clip_multiplier, which is often used to calculate the near clipping plane multiplier of the camera. The near clipping plane is the near end of the frustum and determines the closest distance the camera can see. In this example, near_clip_multiplier is set to 0.01, which means that the near clipping plane may be a value based on the scene size multiplied by 0.01. Continuing with the previous example, if the maximum size of the scene is 10 units, then the near clipping plane may be 0.1 units.

[0028] Step 5: Calculate the camera's far and near clipping planes The far clipping plane of the camera is calculated by the function far_clip_value=max_dim*far_clip_multiplier, where far_clip_value is the far clipping plane of the camera, max_dim is the maximum size of the maximum bounding box, and far_clip_multiplier is the multiple of the far clipping plane of the camera; The near clipping plane of the camera is calculated by the function near_clip_value=min_dim*near_clip_multiplier, where near_clip_value is the near clipping plane of the camera, min_dim is the minimum size of the maximum bounding box, and near_clip_multiplier is the multiple of the near clipping plane of the camera.

[0029] Overall principle: According to the far clipping plane multiplier and near clipping plane multiplier defined in step 4, the maximum size of the bounding box calculated according to step 3 is enlarged by 100 times, that is: multiply the maximum value of the maximum bounding box max_dim calculated in step 3 by the variable far_clip_multiplier defined in step 4, and finally assign the resulting value to the variable far_clip_value; this is done to ensure that the far clipping plane is far enough to include the part of the scene farthest from the camera.

[0030] According to the far clipping plane multiplier and near clipping plane multiplier defined in step 4, the minimum size of the bounding box calculated according to step 3 is reduced by 0.01 times, that is: multiply the minimum value of the maximum bounding box min_dim calculated in step 3 by the variable near_clip_multiplier defined in step 4, and finally assign the resulting value to the variable near_clip_value; this is done to ensure that the far clipping plane is close enough to include the part of the scene closest to the camera.

[0031] Step 6: Get all the cameras in the scene and apply the calculated nearest and farthest clipping plane values cameras=cmds.ls(type='camera') forcameraincameras: cmds.setAttr(camera+'.farClipPlane',far_clip_value) cmds.setAttr(camera+'.nearClipPlane',near_clip_value) Overall principle: This code iterates over all cameras in the scene and updates the far and near clipping planes of each camera using the far_clip_value and near_clip_value calculated previously. This ensures that the farthest clipping plane of all cameras is automatically enlarged by 100 times based on the value of the scene's maximum bounding box, and the nearest clipping plane of all cameras is automatically reduced by 0.01 times based on the value of the scene's minimum bounding box, thus achieving dynamic calculation of the clipping planes.

[0032] Step 61, cameras = cmds.ls (type = 'camera') Define the variable cameras As in step 1, use the cmds.ls function and the filter type='camera' to list all objects of type camera in the scene, obtain a list containing the names of all camera objects, and store it in the variable cameras Step 62: forcameraincameras This line of code starts a for loop that will iterate over each element in the cameras list.

[0033] In each loop, the variable camera will be assigned the name of a camera object in the list. The for loop works like this: First, when the loop starts, the camera variable is set to the first element in the cameras list.

[0034] Then, the code inside the loop is executed. In this example, the code inside the loop is: cmds.setAttr(camera+'.farClipPlane',far_clip_value): Set the far clipping plane of the current camera.

[0035] cmds.setAttr(camera+'.nearClipPlane',near_clip_value): Set the near clipping plane of the current camera.

[0036] After executing the code in the loop body, the loop automatically updates the camera variable to the next element in the list and executes the code in the loop body again.

[0037] This process is repeated until all elements in the cameras list have been traversed.

[0038] Once all elements in the list have been traversed, the loop ends and the program continues to execute the code after the loop Step 63, cmds.setAttr(camera+'.farClipPlane', far_clip_value): This line of code sets the far clipping plane for the camera in the current loop.

[0039] camera+'.farClipPlane' is a string concatenation operation that concatenates the name of the camera object with the .farClipPlane property path to form a complete property path. The purpose of this is to obtain the farClipPlane property of the camera object.

[0040] far_clip_value is a variable that stores the value of the far clipping plane calculated in step 5.

[0041] The cmds.setAttr function is used to set the attribute value of an object. Here, it sets the camera's farClipPlane attribute to far_clip_value, so that the camera's far clipping plane is updated.

[0042] Step 64, cmds.setAttr(camera+'.nearClipPlane',near_clip_value): This line of code sets the near clipping plane for the camera in the current loop.

[0043] camera+'.nearClipPlane' is a string concatenation operation that concatenates the name of the camera object with the .nearClipPlane property path to form a complete property path. The purpose of this is to get the nearClipPlane property of the camera object.

[0044] near_clip_value is a variable that stores the value of the near clipping plane calculated in step 5.

[0045] The cmds.setAttr function is used to set the attribute value of an object. Here, it sets the camera's nearClipPlane attribute to near_clip_value, so that the camera's near clipping plane is updated.

[0046] This, combined with the for loop, ensures that every camera in the scene has its far and near clipping planes updated to the new values.

Claims

1. A method for dynamically calculating a scene virtual camera clipping plane based on a scene boundary, characterized in that: The following steps are involved: Step 1: Get all renderable geometries in the scene; Step 2: Calculate the bounding boxes of all geometric bodies, merge them into the maximum bounding box, and obtain the closest and farthest points of the maximum bounding box relative to the camera; Step 3: Calculate the value of the closest point and the farthest point of the maximum bounding box relative to the camera; Step 4: Define the camera's far clipping plane multiples and near clipping plane multiples; Step 5: Calculate the camera's far clipping plane and near clipping plane; Step 6: Get all the cameras in the scene and set the far clipping plane and near clipping plane.

2. A method for dynamically calculating a scene virtual camera clipping plane based on a scene boundary as claimed in claim 1, characterized in that: In step 1, all geometric bodies in the scene are screened and listed through the function cmds.ls and its calling parameters "geometry=True, noIntermediate=True"; the geometric bodies refer to those 3D objects that can be finally rendered, excluding auxiliary objects created in the modeling process.

3. A method for dynamically calculating a scene virtual camera clipping plane based on a scene boundary as claimed in claim 1, characterized in that: In step 2, the bounding boxes of the world space of all the geometric bodies obtained in step 1 are calculated by calling the function bbox=cmds.exactWorldBoundingBox(geometry), and these bounding boxes are merged into a maximum bounding box, and the coordinate vectors of the nearest and farthest points of the returned maximum bounding box relative to the camera are assigned to the variable bbox; specifically, the following steps are included: Step 21: Determine the object list geometry that needs to calculate the bounding box. The Geometry list includes all the geometric bodies in the scene; Step 22, calculate the bounding box of each geometric body in the list in the local space, and find the smallest cube that can enclose all vertices in its own coordinate system; Step 23: Convert the local bounds of each geometric object to world space. The specific internal method is to multiply each vertex of the local bounding box by the world transformation matrix of the geometric object, so that the bounding box will be equivalent to the coordinate system of the entire world for system positioning; Step 24: Merge the world space bounding boxes of all geometries into a maximum bounding box. Step 25: The final returned result is the coordinate vector of the closest point and the farthest point of the maximum bounding box in the scene relative to the camera.

4. A method for dynamically calculating a scene virtual camera clipping plane based on a scene boundary as claimed in claim 1, characterized in that: In S3, the value of the closest point and the value of the farthest point of the maximum bounding box relative to the camera are calculated as follows: max_dim=max(maxX-minX,maxY-minY,maxZ-minZ); min_dim=min(maxX-minX,maxY-minY,maxZ-minZ); Among them, max_dim and min_dim are the maximum distance and minimum distance of the maximum bounding box in three dimensions, maxX–minX is the length of the maximum bounding box on the x-axis, maxY–minY is the length of the maximum bounding box on the y-axis, and maxZ–minZ is the length of the maximum bounding box on the z-axis.

5. A method for dynamically calculating a scene virtual camera clipping plane based on a scene boundary as claimed in claim 1, characterized in that: In step 4, the far clipping plane multiple and the near clipping plane multiple of the camera are custom values.

6. A method for dynamically calculating a scene virtual camera clipping plane based on a scene boundary as claimed in claim 1, characterized in that: In step 5: The far clipping plane of the camera is calculated by the function far_clip_value=max_dim*far_clip_multiplier, where far_clip_value is the far clipping plane of the camera, max_dim is the maximum size of the maximum bounding box, and far_clip_multiplier is the multiple of the far clipping plane of the camera; The near clipping plane of the camera is calculated by the function near_clip_value=min_dim*near_clip_multiplier, where near_clip_value is the near clipping plane of the camera, min_dim is the minimum size of the maximum bounding box, and near_clip_multiplier is the multiple of the near clipping plane of the camera.

7. A method for dynamically calculating a scene virtual camera clipping plane based on a scene boundary as claimed in claim 1, characterized in that: In step 6, a for loop is used to traverse all cameras in the scene, and the far clipping plane and the near clipping plane of the camera obtained in step 5 are assigned to each camera, thereby finally realizing the dynamic calculation of the camera clipping plane.

Citation Information

Patent Citations

  • Three-dimensional visualization multi-scene rendering application integration method

    CN117689791A

  • Resetting method and device for cover image of virtual object, equipment, medium and program

    CN118349152A

  • Automatically generating appropriate near and far clipping planes for a 3D scene while guaranteeing minimum of Z-buffer precision

    US20070216710A1

  • Method for automatically cropping digital images

    US20100329550A1

  • Storage medium storing display control program, storage medium storing library program, information processing system, and display control method

    US20110090215A1

Cited By

  • Three-dimensional camera automatic positioning method and device based on scene size self-adaption

    CN121616641A