Abstract:
A method of mapping a two-dimensional image to a three-dimensional surface includes capturing data for a two-dimensional image and a three-dimensional structure. A process determines coincident points between the 2D image and the 3D structure and maps points on the 2D image to the 3D structure by assigning relative two-coordinate points from the two dimensional image to relative three-coordinate points of the three-dimensional structure. The mapping creates a 3D surface and texturing and removes superfluous data from the created three-dimensional surface to clean the mapped resultant.

Description:
CROSS REFERENCE TO RELATED APPLICATION 
       [0001]    This application is a non-provisional application claiming priority from U.S. Provisional Application Ser. No. 61/685,678, filed Mar. 22, 2012, entitled “Method of mapping a 2D image to a 3D surface”, U.S. Provisional Application Ser. No. 61/732,164, filed Aug. 3, 2012, entitled “System and Method of Mapping a 2D Image to a 3D Structure”, and U.S. Provisional Application Ser. No. 61/797,143, filed Nov. 30, 2012, entitled “Method of mapping a 2D image to a 3D surface”, each of which are incorporated herein by reference in their entirety. 
     
    
     FIELD OF THE DISCLOSURE 
       [0002]    The present disclosure relates generally to computer visualization and more particularly to systems and methods for geometrically mapping two-dimensional images to three-dimensional surfaces. 
       BACKGROUND OF RELATED ART 
       [0003]    Texturing three-dimensional (3D) surfaces with two-dimensional (2D) graphics is commonplace in the field of computer visualization. For example, visualization is a rapidly advancing field which provides immersive environments that can be enhanced by employing 3D viewing hardware. The use of such environments is now commonplace in technical and scientific fields where the correct interpretation of data is vital in both diagnostics and extending the frontiers of knowledge. Such fields generally require geometrically correct rendering of data in contrast to many areas of the entertainment industry, and hence specialist techniques are required. 
         [0004]    A point-cloud is a set of vertices in a three-dimensional coordinate system. These vertices are usually defined by X, Y, and Z coordinates, and typically are intended to be representative of the internal and external surface of an object. Point-clouds are most often created by 3D scanners. These devices measure in an automatic way a large number of points on the surface of an object, and often output a point-cloud as a data file. The point-cloud represents the set of points that the device has measured. 
         [0005]    As the result of a 3D scanning process point-clouds are used for many purposes, including to create 3D CAD models for manufactured parts, metrology/quality inspection, post-acquisition analysis (e.g., engineers and/or scholars) and a multitude of visualization, animation, rendering and mass customization applications. 
         [0006]    In one example, U.S. Pat. No. 5,412,765 describes a method for visualizing vector fields uses texture mapping for the vectors to create an animated vector field. The described methods utilize time lapse as a component. Specifically, vectors are textured with one dimensional texture maps composed of alternating visible and invisible segments. Successively applied texture maps differ from each other in order to create a moving line effect on the vectors being visualized. A fading effect is further provided by varying the intensity of the visible segments. 
         [0007]    Meanwhile, U.S. Pat. No. 7,689,019 describes a method for registering a 2D projection image of an object relative to a 3D image data record of the same object, in which, from just a few 2D projection images, a 3D feature contained in an object, which is also identifiable in the 3D images, is symbolically reconstructed. The 3D feature obtained in this way is then registered by 3D-3D registration with the 3D image data record. The methods described identify three features on the target structure, form, surface, and centerline. 
         [0008]    While the known systems and methods may work for their intended purposes, there is a known need in the art to provide improvements thereto. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0009]    These and other features, aspects and advantages of the present disclosure will become better understood with regard to the following description, appended claims, and accompanying drawings. 
           [0010]      FIG. 1  is a block diagram illustrating components of an example network system in which the disclosed systems and methods may be employed. 
           [0011]      FIG. 2A  shows an example architectural 3D point-cloud. 
           [0012]      FIG. 2B  shows an example 2D image corresponding to the example 3D point-cloud of  FIG. 2A . 
           [0013]      FIG. 3  illustrates an example process diagram for mapping an example 2D image to an example 3D point-cloud. 
           [0014]      FIG. 4  illustrates an example block diagram of sample calculations utilized in the process of  FIG. 3 . 
           [0015]      FIG. 5  illustrates an example process which allows for the blending of image date and the removal of visual artifacts. 
           [0016]      FIG. 6  illustrates an example of the determination of surface 3D point-cloud data from general 3D data. 
           [0017]      FIG. 7A  illustrates an example image before any normalization and cleaning process. 
           [0018]      FIG. 7B  illustrates the example image of  FIG. 7A  after an example normalization and cleaning process. 
           [0019]      FIG. 8A  illustrates an example image before compression. 
           [0020]      FIG. 8B  illustrates the example image of  FIG. 8A  after an example compression process. 
           [0021]      FIG. 9  illustrates an example image showing the partial rendering using an example internal camera from a scanner. 
           [0022]      FIG. 10  is an example plot illustrating the remaining points after reduction using a center comparison process. 
           [0023]      FIG. 11  is an example plot illustrating the remaining points after reduction using a two norm comparison process. 
           [0024]      FIG. 12A  illustrates an example 3D point-cloud of an architectural object. 
           [0025]      FIG. 12B  illustrates the resultant 3D point-cloud of  FIG. 12A  rendered as a surface utilizing the example methods of the present invention. 
           [0026]      FIG. 13A  illustrates an example 3D point-cloud of a CT Scan of an object. 
           [0027]      FIG. 13B  illustrates the resultant 3D point-cloud of  FIG. 13A  rendered as a surface utilizing the example methods of the present invention. 
       
    
    
     DETAILED DESCRIPTION 
       [0028]    The following descriptions of various examples are not intended to limit the scope of the descriptions to the precise form or forms detailed herein. Instead the following descriptions are intended to be illustrative so that others may follow their teachings. 
         [0029]    The present disclosure provides methods of determining the geometrically correct registration between a 2D image, or images, and the underlying 3D surface associated with them to allow automatic alignment of, for example, many images to many point-clouds. The requirement arises from technical and scientific fields, such as architecture and/or historical preservation, where, for example, a measurement from the underlying 3D data needs to be determined by observation of surface data. In this example, the present disclosure facilitates the combination of photographic data from multiple viewpoints with 3D data from laser scanners or Computer Aided Design (CAD) computer programs, to generate immersive environments where the user can query the underlying data by visual interpretation. Another example allows the combination of surface data, including internal surfaces, for biological specimens with CT scan data for diagnostic or educational purposes. In yet another example, the present disclosure allows for mapping of multiple images acquired from robotic tripods, such as a GigaPan tripod with a camera attached, to scanned data from scanners such as the Leica C10. In still another example, the present disclosure maps images from camera enabled scanners to point-clouds. 
         [0030]    Acquisition of 3D data and the associated 2D surface data can be accomplished in a number of ways, depending on the problem. Where it is possible to use a single scan to obtain both 3D coordinates and surface images simultaneously, registration of the sets of data is guaranteed but with known technology, the object has to be of the order of 1 cm to 1 m in size. In many situations this is not possible, for example large architectural structures, landscapes, large area scenes, nano or biological-scale objects and data from devices such as CT scanners, etc. 
         [0031]    In such cases, previous methods have manually adjusted the registration between the data sets visually, which does not guarantee the fidelity of registration over the full extents of the data sets and, in general, cannot correctly align the data sets. There also exist computer programs to approximately align the data to produce single point visualizations. In general this visualization cannot be rotated through all viewpoints and it is not possible to measure surface features based on the underlying 3D data. 
         [0032]    In the present disclosure, 3D data, such as point-cloud data, is automatically combined with 2D surface data, which may include internal surfaces, such that the registration between the data sets, and hence the validity of observations and measurements based on them, is determined geometrically and maintained over the surface of interest. Where multiple sets of 2D data are available for the same surface area, the optimal set can be determined for each rendered pixel set. In addition, visual artifacts generally present with adjacent multiple images can be reduced. The surface images do not have to be produced from fixed viewpoints in relation to the 3D representation, or map directly to individual 3D features of the object, allowing the acquisition of data from the architectural to nano scales. This is particularly important from complex surfaces, for example those generated from biological specimens. 
         [0033]    Still further, 3D points are culled from individual point-clouds, where a number of point-clouds are used, to reduce or eliminate overlap for optimal texturing. 3D points are culled from individual point-clouds to remove artifacts where the distance between adjacent points is large, indicating a real spatial separation. 3D points are culled to reduce their number, and hence the number of triangles, for efficiency, such that important features (such as edges) are preserved. 
         [0034]    In one of the present disclosure, 3D data is combined with 2D surface images acquired from the same device, mapping images from camera enabled scanners to point-clouds. In another example of the present disclosure there is described a process of mapping multiple images acquired from robotic tripods, such as a GigaPan robotic tripod, to 3D scan data. The systems and methods disclosure herein also facilitates the combination of photographic data with 3D data from laser scanners to generate immersive environments where the user can query the underlying data by visual interpretation. As such, the examples disclosed have found particular use in, but are not restricted to, architectural and biological diagnostic fields. 
         [0035]    With reference to the figures, systems and methods for mapping 2D images to 3D surfaces is now described. While not intended to be limiting, the systems and methods will be described in the context of a plurality of processing devices linked via a network, such as a local area network or a wide area network, as illustrated in  FIG. 1 . In this regard, a processing device  20 , illustrated in the exemplary form of a computer system, is provided with executable instructions to, for example, provide a means for an operator, i.e., a user, to access a remote processing device, e.g., a server system  68 , via the network to, among other things, distribute processing power to map 2D images to 3D surfaces. Generally, the computer executable instructions disclosed herein reside in program modules which may include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. Accordingly, those of ordinary skill in the art will appreciate that the processing device  20  may be embodied in any device having the ability to execute instructions such as, by way of example, a personal computer, mainframe computer, personal-digital assistant (“PDA”), cellular or smart telephone, tablet computer, or the like. Furthermore, while described and illustrated in the context of a single processing device  20 , those of ordinary skill in the art will also appreciate that the various tasks described hereinafter may be practiced in a distributed environment having multiple processing devices linked via a local or wide-area network whereby the executable instructions may be associated with and/or executed by one or more of multiple processing devices, e.g., in a cloud computing environment. 
         [0036]    For performing the various tasks in accordance with the executable instructions, the processing device  20  preferably includes a processing unit  22  and a system memory  24  which may be linked via a bus  26 . Without limitation, the bus  26  may be a memory bus, a peripheral bus, and/or a local bus using any of a variety of bus architectures. As needed for any particular purpose, the system memory  24  may include read only memory (ROM)  28  and/or random access memory (RAM)  30 . Additional memory devices may also be made accessible to the processing device  20  by means of, for example, a hard disk drive interface  32 , a magnetic disk drive interface  34 , and/or an optical disk drive interface  36 . As will be understood, these devices, which would be linked to the system bus  26 , respectively allow for reading from and writing to a hard disk  38 , reading from or writing to a removable magnetic disk  40 , and reading from or writing to a removable optical disk  42 , such as a CD/DVD ROM or other optical media. The drive interfaces and their associated non-transient, computer-readable media allow for the nonvolatile storage of computer readable instructions, data structures, program modules, and other data for the processing device  20 . Those of ordinary skill in the art will further appreciate that other types of non-transient, computer readable media that can store data may be used for this same purpose. Examples of such media devices include, but are not limited to, magnetic cassettes, flash memory cards, digital videodisks, Bernoulli cartridges, random access memories, nano-drives, memory sticks, and other read/write and/or read-only memories. 
         [0037]    A number of program modules may be stored in one or more of the memory/media devices. For example, a basic input/output system (BIOS)  44 , containing the basic routines that help to transfer information between elements within the processing device  20 , such as during start-up, may be stored in ROM  28 . Similarly, the RAM  30 , hard drive  38 , and/or peripheral memory devices may be used to store computer executable instructions comprising an operating system  46 , one or more applications programs  48 , other program modules  50 , and/or program data  52 . Still further, computer-executable instructions may be downloaded to one or more of the computing devices as needed, for example, via a network connection. 
         [0038]    The operator may enter commands and information into the processing device  20 , e.g., a textual search query, a selection input, etc., through input devices such as a keyboard  54  and/or a pointing device  56 . While not illustrated, other input devices may include a microphone, a joystick, a game pad, a scanner, a camera, etc. These and other input devices would typically be connected to the processing unit  22  by means of an interface  58  which, in turn, would be coupled to the bus  26 . Input devices may be connected to the processor  22  using interfaces such as, for example, a parallel port, game port, Firewire, a universal serial bus (USB), etc. To view information from the processing device  20 , a monitor  60  or other type of display device may also be connected to the bus  26  via an interface, such as a video adapter  62 . In addition to the monitor  60 , the processing device  20  may also include other peripheral output devices, not shown, such as speakers, printers, 3D rendering hardware such as 3D glasses to separate right-left vision and autosteroscopic screens, etc. 
         [0039]    The processing device  20  may also utilize logical connections to one or more remote processing devices, such as the server system  68  having one or more associated data repositories  68 A, e.g., a database. In this regard, while the server system  68  has been illustrated in the exemplary form of a computer, it will be appreciated that the server system  68  may, like processing device  20 , be any type of device having processing capabilities. Again, it will be appreciated that the server system  68  need not be implemented as a single device but may be implemented in a manner such that the tasks performed by the server system  68  are distributed to a plurality of processing devices linked through a communication network. Additionally, the server system  68  may have logical connections to other third party server systems via the network  12  and, via such connections, will be associated with data repositories and/or functionalities that are associated with such other third party server systems. 
         [0040]    For performing tasks as needed, the server system  68  may include many or all of the elements described above relative to the processing device  20 . By way of further example, the server system  68  includes executable instructions stored on a non-transient memory device for, among other things, handling mapping requests, etc. Communications between the processing device  20  and the server system  68  may be exchanged via a further processing device, such as a network router, that is responsible for network routing. Communications with the network router may be performed via a network interface component  73 . Thus, within such a networked environment, e.g., the Internet, World Wide Web, LAN, or other like type of wired or wireless network, it will be appreciated that program modules depicted relative to the processing device  20 , or portions thereof, may be stored in the memory storage device(s) of the server system  68 . 
         [0041]    An example of an architectural 3D point-cloud  10  and corresponding 2D image  12  is illustrated in  FIGS. 2A and 2B , respectively. In the present disclosure, a set of processes describe a method for geometrically determining the correct registration between a 2D image, or images, and the underlying 3D surface associated with the subject image(s). Still further, there is disclosed a process for mapping of a single image to a 3D surface point-cloud, as well as extending to multiple images from different viewpoints. Finally, there are described processes for extracting surface 3D point-clouds from general 3D data, such as for example, point-clouds, CT scans, or the like. 
         [0042]    For simplicity of understanding, the following disclosure assumes that the user has a 3D point-cloud of surface points i.e., a collection of points in 3 dimensional space representing a surface which may be internal to the object, and a single 2D image which overlaps with the 3D data. Furthermore, the presently described systems and methods also assume the position of the camera is known in relation to the point-cloud. It will be appreciated, however, that the position of the camera need not be known in relation to the point-cloud and may be calculated and/or otherwise determined utilizing any suitable calculation method. Use of the present disclosure with multiple images and the generation of surface point-clouds from data, such as general point-clouds, CT scans, etc., will be discussed as well. 
         [0043]    In the present example, the 3D point-cloud data may be obtained from any suitable source, including for instance, a scanner such as a Leica scanner available from Leica Geosystems AG, St. Gallen, Switzerland (for architectural use). Additionally, in this example, the 2D image may be selected from any suitable imaging source, such as an image from a set obtained using a GigaPan robotic tripod in association with an SLR camera, a high-resolution imaging system. 
       Mapping 2D Image to 3D Point-Cloud 
       [0044]    Turning to  FIGS. 3 and 4 , in one example of the present disclosure, a process  300  for mapping a 2D image to a 3D point-cloud is illustrated. In this example, processing starts at a block  302 , wherein two coincident points between the 2D image and the 3D point-cloud are determined. Referring to  FIG. 4 , in a 3D point-cloud  400 , two points, A and B in the 3D data  400 , and the 2D image are determined. While not necessarily limiting, for his example, we will assume point A is closer to the center of the image  400 . As illustrated, the ‘noses’ of the two statues are used. 
         [0045]    Once the two coincident points are determined, the process  300  will continue with a block  304 , wherein the process  300  finds the viewpoint. In other words, the process  304  finds the vector from the camera origin O (see reference  402 ,  FIG. 4 ) to point A, denoted as vector C. Without loss of generality the process  300  assumes that point O is at the system origin. 
         [0000]        O =(0,0,0)  Eq.1
 
         [0046]    Upon determination of the viewpoint, the process  300  continues with a determination of the viewing plane at a block  306 . In this instance, the process  300  constructs a plane P (reference  406 ,  FIG. 4 ) with a normal vector C without loss of generality. The example plane P ( 406 ) is constructed, at a distance  1  from the camera origin O ( 402 ). As such, using Eq. (1), a point on the plane is Â=A/∥A∥ and the vector from the origin O to pointÂ, Â−O, is a unit normal vector to the plane. Then for point p on plane P, using Eqn. (1), 
         [0000]        p .( Â−O )− Â .( Â−O )= p.Â− 1=0  Eq. 2
 
         [0047]    Processing then continues with a block  608 , wherein the process  300  finds the points in the viewing plane. Specifically, for each point P, on the 3D surface, the process draws a line L i  from the camera origin O to the point P i  and finds the point of intersection with the plane P, PP i   4 . For point  1  on the line L and parameter t we have: 
         [0000]      1 =O+t ( P   i −0)  Eq. 3
 
         [0000]    which intersects the plane P when: 
         [0000]    
       
         
           
             
               
                 
                   t 
                   = 
                   
                     
                       
                         - 
                         1 
                       
                       - 
                       
                         O 
                         · 
                         
                           ( 
                           
                             
                               A 
                               ^ 
                             
                             - 
                             O 
                           
                           ) 
                         
                       
                     
                     
                       
                         ( 
                         
                           
                             P 
                             i 
                           
                           - 
                           O 
                         
                         ) 
                       
                       · 
                       
                         ( 
                         
                           
                             A 
                             ^ 
                           
                           - 
                           O 
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   4 
                 
               
             
           
         
       
     
         [0000]    Using Eqs. 1-4, this reduces to 
         [0000]    
       
         
           
             
               
                 
                   
                     PP 
                     i 
                   
                   = 
                   
                     
                       P 
                       i 
                     
                     
                       
                         P 
                         i 
                       
                        
                       
                         A 
                         ^ 
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   5 
                 
               
             
           
         
       
     
         [0048]    The process  300  then finds the Y-axis in the viewing plane at a block  310 . In this instance, the process defines a “vertical” plane VP containing the vector C, and finds the line Y where this plane intersects the plane P. This axis will be the “y-axis” for the 2D image. In one example, this can be accomplished by adding a vertical offset V offs  to point A to give a point V=A+V offs , and a new point on the plane V can be calculated using the technique in Eq. 5. 
         [0000]    
       
         
           
             
               
                 
                   
                     V 
                     _ 
                   
                   = 
                   
                     V 
                     
                       V 
                        
                       
                           
                       
                        
                       
                         A 
                         ^ 
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   6 
                 
               
             
           
         
       
     
         [0000]    And the process  300  requires a unit vector Ŷ in the “y” direction from the plane origin, hence: 
         [0000]    
       
         
           
             
               
                 
                   
                     Y 
                     ^ 
                   
                   = 
                   
                     
                       
                         V 
                         _ 
                       
                       - 
                       
                         A 
                         ^ 
                       
                     
                     
                        
                       
                         
                           V 
                           _ 
                         
                         - 
                         
                           A 
                           ^ 
                         
                       
                        
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   7 
                 
               
             
           
         
       
     
         [0049]    The process  300  also finds the X-axis in the viewing plane at a block  312 . In this instance, the line Y is rotated through 90 degrees clockwise in the plane P around the point where the vector C intersects the plane P. It will, however, be appreciated that the order and/or methodology for determining the Y and X axis may vary as desired. In this example, given 
         [0000]        O =( a,b,c ),    V = ( x,y,z )  Eq. 8
 
         [0000]    The process  300  finds a point H rotated around Â in the plane P, (including u=a, v=b, w=c) 
         [0000]    
       
         
           
             
               dotp 
               = 
               
                 
                   u 
                   * 
                   x 
                 
                 + 
                 
                   v 
                   * 
                   y 
                 
                 + 
                 
                   w 
                   * 
                   z 
                 
               
             
             , 
             
               
 
             
              
             
               H 
               = 
               
                 
                   ( 
                   
                     
                       
                         
                           
                             
                               
                                 
                                   a 
                                   * 
                                   
                                     ( 
                                     
                                       
                                         v 
                                         * 
                                         v 
                                       
                                       + 
                                       
                                         w 
                                         * 
                                         w 
                                       
                                     
                                     ) 
                                   
                                 
                                 + 
                                 
                                   u 
                                   * 
                                   
                                     ( 
                                     
                                       
                                         
                                           - 
                                           b 
                                         
                                         * 
                                         v 
                                       
                                       - 
                                       
                                         c 
                                         * 
                                         w 
                                       
                                       + 
                                       dotp 
                                     
                                     ) 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   ( 
                                   
                                     
                                       
                                         - 
                                         c 
                                       
                                       * 
                                       v 
                                     
                                     + 
                                     
                                       b 
                                       * 
                                       w 
                                     
                                     - 
                                     
                                       w 
                                       * 
                                       y 
                                     
                                     + 
                                     
                                       v 
                                       * 
                                       z 
                                     
                                   
                                   ) 
                                 
                                 , 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               
                                 
                                   b 
                                   * 
                                   
                                     ( 
                                     
                                       
                                         u 
                                         * 
                                         u 
                                       
                                       + 
                                       
                                         w 
                                         * 
                                         w 
                                       
                                     
                                     ) 
                                   
                                 
                                 + 
                                 
                                   v 
                                   * 
                                   
                                     ( 
                                     
                                       
                                         
                                           - 
                                           a 
                                         
                                         * 
                                         u 
                                       
                                       - 
                                       
                                         c 
                                         * 
                                         w 
                                       
                                       + 
                                       dotp 
                                     
                                     ) 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   ( 
                                   
                                     
                                       c 
                                       * 
                                       u 
                                     
                                     - 
                                     
                                       a 
                                       * 
                                       w 
                                     
                                     + 
                                     
                                       w 
                                       * 
                                       x 
                                     
                                     - 
                                     
                                       u 
                                       * 
                                       z 
                                     
                                   
                                   ) 
                                 
                                 , 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               
                                 
                                   c 
                                   * 
                                   
                                     ( 
                                     
                                       
                                         u 
                                         * 
                                         u 
                                       
                                       + 
                                       
                                         v 
                                         * 
                                         v 
                                       
                                     
                                     ) 
                                   
                                 
                                 + 
                                 
                                   w 
                                   * 
                                   
                                     ( 
                                     
                                       
                                         
                                           - 
                                           a 
                                         
                                         * 
                                         u 
                                       
                                       - 
                                       
                                         b 
                                         * 
                                         v 
                                       
                                       + 
                                       dotp 
                                     
                                     ) 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       - 
                                       b 
                                     
                                     * 
                                     u 
                                   
                                   + 
                                   
                                     a 
                                     * 
                                     v 
                                   
                                   - 
                                   
                                     v 
                                     * 
                                     x 
                                   
                                   + 
                                   
                                     u 
                                     * 
                                     y 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                   ) 
                 
                 . 
               
             
           
         
       
     
         [0000]    Requiring a unit vector {circumflex over (X)} in the ‘x’ direction from the origin Â hence 
         [0000]    
       
         
           
             
               
                 
                   
                     X 
                     ^ 
                   
                   = 
                   
                     
                       H 
                       - 
                       
                         A 
                         ^ 
                       
                     
                     
                        
                       
                         H 
                         - 
                         
                           A 
                           ^ 
                         
                       
                        
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   9 
                 
               
             
           
         
       
     
         [0050]    Once the X and Y axis are determined, the process  300  continues at a block  314 , wherein the planar points are projected onto the “x-y” axes. In this instance, each of the points PP, are projected onto the x and y axes to determine their ‘x-y’ coordinates PPX i  and PPY i . This may be determined through the equation: 
         [0000]        PPX   i =( PP   i   −Â ). {circumflex over (X)}   
         [0000]        PPY   i =( PP   i   −Â ). Ŷ   Eq.10
 
         [0051]    At a block  316 , the process finds the scale factors and offsets for the 2D image. For example, the process  300  calculates a scale factor S and the ‘x-y’ offsets X off  and Y off  for the 2D image. Given that points A and B on the 3D point-cloud  400  correspond to points Â and {circumflex over (B)} in the plane P, and assuming these points on the 2D image have ‘x-y’ coordinates (a x , a y ) and (b x , b y ), respectively, the process  300  can determine that 
         [0000]    
       
         
           
             
               
                 
                   S 
                   = 
                   
                     
                        
                       
                         B 
                         - 
                         A 
                       
                        
                     
                     
                       
                         ( 
                         
                           
                             
                               ( 
                               
                                 
                                   b 
                                   x 
                                 
                                 - 
                                 
                                   a 
                                   x 
                                 
                               
                               ) 
                             
                              
                             
                               ( 
                               
                                 
                                   b 
                                   x 
                                 
                                 - 
                                 
                                   a 
                                   x 
                                 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               ( 
                               
                                 
                                   b 
                                   y 
                                 
                                 - 
                                 
                                   a 
                                   y 
                                 
                               
                               ) 
                             
                              
                             
                               ( 
                               
                                 
                                   b 
                                   y 
                                 
                                 - 
                                 
                                   a 
                                   y 
                                 
                               
                               ) 
                             
                           
                         
                         ) 
                       
                       
                         1 
                         2 
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   11 
                 
               
             
             
               
                 
                   
                     x 
                     off 
                   
                   = 
                   
                     - 
                     
                       a 
                       x 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   12 
                 
               
             
             
               
                 
                   
                     y 
                     off 
                   
                   = 
                   
                     - 
                     
                       a 
                       y 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   13 
                 
               
             
           
         
       
     
         [0052]    Once the scale factor S and the ‘x-y’ offsets are determined, the process calculates the actual ‘x-y’ coordinates for all points at a block  318 . In this example, the process  300  may utilize the equation: 
         [0000]    
       
      
       ppx 
       i 
       =PPX 
       i 
       *S−x 
       off  
      
     
         [0000]        ppy   i   =PPY   i   *S−   off   Eq. 14
 
         [0053]    The process  300  may then create a 3D surface and texture using the 2D coordinates corresponding to each 3D point at a block  322 . The surface texturing may be accomplished through any suitable procedure, including, for example, the procedure disclosure in Table 1. As an example the process  300  may draw a single OpenGL Quad (see Table 1) textured by one quadrilateral from the image (consisting of four adjacent points in the point-cloud). It will be understood that while the present example is provided in openGL, any suitable process may be utilized as desired. In the example disclosure herein, it is assumed for illustration purposes only that the top left point on the Quads 3D point-cloud is P 2 , the bottom left P 10 , the bottom right P 11  and the top right P 3 , with corresponding actual ‘x-y’ coordinates of the image (ppx — 2, ppy —2 ), (ppx — 10, ppy — 10), (ppx — 10, ppy — 10) and (ppx — 3, ppy — 3) (for ease of representation, the nomenclature has changed from ppx i  to ppx_i in the example of Table 1). 
         [0000]    
       
         
               
               
             
           
               
                 TABLE 1 
               
               
                   
               
             
             
               
                   
                 // Draw a Single Quad 
               
               
                   
                 glBegin(GL_QUADS); 
               
               
                   
                  //set normal 
               
               
                   
                  glNormal3f(normal.x( ), normal.y( ), normal.z( )); 
               
               
                   
                  glTexCoord2f (ppx_2, ppy_2); 
               
               
                   
                  glVertex3f(top_left_position.x( ), 
               
               
                   
                  top_left_position.y( ), 
               
               
                   
                   top_left_position.z( ));    // 
               
               
                   
                  Top Left glNormal3f(normal.x( ), normal.y( ), 
               
               
                   
                  normal.z( )); glTexCoord2f (ppx_10, ppy_10)); 
               
               
                   
                  glVertex3f(bottom_left_position.x( ), bottom_left_position.y( ), 
               
               
                   
                   bottom_left_position.z( ));    // 
               
               
                   
                  Bottom Left glNormal3f(normal.x( ), normal.y( ), normal.z( )); 
               
               
                   
                  glTexCoord2f (ppx_11, ppy_11)); 
               
               
                   
                  glVertex3f(bottom_right_position.x( ), 
               
               
                   
                  bottom_right_position.y( ), 
               
               
                   
                   bottom_right_position.z( ));    // 
               
               
                   
                  Bottom Right glNormal3f(normal.x( ), normal.y( ), normal.z( )); 
               
               
                   
                  glTexCoord2f (ppx_3, ppy_3)); 
               
               
                   
                  glVertex3f(top_right_position.x( ), 
               
               
                   
                  top_right_position.y( ), 
               
               
                   
                   top_right_position.z( ) );    // Top Right 
               
               
                   
                 glEnd( ); 
               
               
                   
               
             
          
         
       
     
         [0054]    In the example Quad textured process, The vector “normal” represents a normal vector to the Quad for the calculation of lighting effects and can be found as: 
         [0000]      normal=( P   10   −P   2 )×( P   3   −P   2 )  Eq. 15
 
         [0000]    wherein X is the cross product. 
       Mapping Multiple Overlapping Images 
       [0055]    The processes described herein can be extended to multiple images by considering each image separately. Where images overlap, however, the process  300  needs to choose the optimal image section to render. Specifically, image overlap can be advantageous during data capture to ensure continuity of data over the entire surface of interest, i.e. all 3D points are associated with image data. Overlapping images also allow fill-in of areas that would be hidden by other features of the object being rendered. 
         [0056]    Referring then to  FIG. 5 , there is presented a process  500  which allows for the blending of image data and the removal of visual artifacts. In this example, the process  500  first calculates the areas for each corresponding image section, generally a triangle or quadrilateral, for the adjacent 3D points of interest at a block  502 . The area A can be calculated for a triangle with vertices V 0 , V 1 , V 2  as 
         [0000]    
       
         
           
             
               
                 
                   A 
                   = 
                   
                     
                       1 
                       2 
                     
                      
                     
                        
                       
                         
                           ( 
                           
                             
                               V 
                               1 
                             
                             - 
                             
                               V 
                               0 
                             
                           
                           ) 
                         
                         × 
                         
                           ( 
                           
                             
                               V 
                               2 
                             
                             - 
                             
                               V 
                               1 
                             
                           
                           ) 
                         
                       
                        
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   16 
                 
               
             
           
         
       
     
         [0000]    for 2D coordinates with V i =(x i , y i ) 
         [0000]    
       
         
           
             
               
                 
                   A 
                   = 
                   
                     
                       1 
                       2 
                     
                      
                     
                        
                       
                         
                           
                             ( 
                             
                               
                                 x 
                                 1 
                               
                               - 
                               
                                 x 
                                 0 
                               
                             
                             ) 
                           
                            
                           
                             ( 
                             
                               
                                 y 
                                 2 
                               
                               - 
                               
                                 y 
                                 0 
                               
                             
                             ) 
                           
                         
                         - 
                         
                           
                             ( 
                             
                               
                                 x 
                                 2 
                               
                               - 
                               
                                 x 
                                 0 
                               
                             
                             ) 
                           
                            
                           
                             ( 
                             
                               
                                 y 
                                 1 
                               
                               - 
                               
                                 y 
                                 0 
                               
                             
                             ) 
                           
                         
                       
                        
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   17 
                 
               
             
           
         
       
     
         [0000]    For example, given images I 1  and I 2  with areas A 1  and A 2 , if A 2 ≧A 1  the process  500  will use the section from image I 2 , else the process will use the section from I 1 . 
         [0057]    The process  500  may also select the image section with the largest area after adding a random perturbation to the area. In this instance, the process  500  allows ‘blending’ of the images to prevent artifacts such as image interface lines. Using the nomenclature from Equations 16 and 17, if A 2 +R≧A 1 , the process  500  uses the section from image I 2 , else the process uses the section from I 1 , for random variable R, which may preferably be determined with zero mean and known distribution. 
         [0058]    Still further, the process  500  may select the image section with the largest area up to some error E, and if the areas are within some chosen error E, merge the image data during texturing. This process allows the ‘blending’ of the images to prevent artifacts such as image exposure level/color differences. In this example, if A 2 &gt;A 1 +E, the process  500  uses the section from I 2 , and if A 1 &gt;A 2 +E, the process  500  uses the section from I 1 . Else, the process  500  blends the sections from I 1  and I 2 . Blending can be accomplished utilizing any suitable blending procedure, including, for example, an example OpenGL as shown in Table 2. 
         [0000]    
       
         
               
             
           
               
                 TABLE 2 
               
               
                   
               
             
             
               
                 glBindTexture(GL_TEXTURE_2D, texture[0]); // Select Texture 1 (0) glBegin(GL_QUADS); // Begin Drawing the Quad 
               
               
                 ... 
               
               
                 glEnd( ); 
               
               
                 glBlendFunc(GL_SRC_ALPHA, GL_ONE); // Set Blending Mode To Mix Based On SRC Alpha glEnable(GL_ALPHA); 
               
               
                 glBindTexture(GL_TEXTURE_2D, /*your alpha channel texture*/ texture[2]); // Select Texture 2 (0) glBegin(GL_QUADS); // Begin 
               
               
                 Drawing the Quad 
               
               
                 ... 
               
               
                 glEnd( ); 
               
               
                   
               
             
          
         
       
     
         [0059]    The example process illustrated in Table 2 effectively finds the image that is most closely aligned with the area defined in the 3D point-cloud, but also allows blending of image data to reduce artifacts. 
         [0000]    Determination of the Surface 3D Point-Cloud from General 3D Data 
         [0060]    Some data, for example computed tomography (CT scan), may contain general 3D coordinates not restricted to surface points of the object. In such instance, the 3D surface point-cloud can be extracted from the data utilizing a process  600  as illustrated in  FIG. 6 . It will be appreciated that the process  600  assumes the camera position and viewpoint is known, but it will be understood that in various examples, the camera position and/or viewpoint can be determined as needed by one of ordinary skill in the art. 
         [0061]    In the example process  600 , the viewpoint plane is first defined at a block  602 . In this process, a plane P is constructed with the camera viewpoint (e.g, a vector describing the viewing direction of the camera) vector A as a normal plane. Assuming without loss of generality that the camera is positioned at the origin and the plane P is at a distance  1  from the camera. Using these assumptions, a point on the plane is Â=A/∥A∥ and Â is also unit normal vector to the plane. Then for a point p on plane P 
         [0000]        p.Â− 1=0  Eq. 18
 
         [0062]    Once the viewpoint plane is defined, the example process  600  defines the Y-axis at a block  604 . In this example, the process  600  defines a camera ‘vertical’ plane VP containing a vector A, and finds the line Y, where this plane intersects the plane P. This intersect will be considered the 2D image ‘y’ axis. As previously noted, this can be accomplished by adding a vertical offset V offs  to point A to give point V=A+V offs , and a new point on the plane V can be calculated using the technique noted in Eq. 5. 
         [0000]    
       
         
           
             
               
                 
                   
                     V 
                     _ 
                   
                   = 
                   
                     V 
                     
                       V 
                       · 
                       
                         A 
                         ^ 
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   19 
                 
               
             
           
         
       
     
         [0000]    For a point y and parameter t on the line y, the process concludes 
         [0000]        y=Â+t (   V −Â ) Eq.  20 
         [0063]    Once the y-axis is determined, the process  600  performs a step of determining the x-axis at a block  606 . As with the previous example, the x-axis may be determined through the rotation of the line y through 90 degrees clockwise in the plane P around the point where the vector A intersects the plane P. This line X is the x-axis. Given that: 
         [0000]        O =( a,b,c ),   V = ( x,y,z )  Eq. 21
 
         [0000]    The process  600  can then find point H rotated around O in the plane P (utilizing u=a, v=b, w=c) 
         [0000]    
       
         
           
             
                 
             
              
             
               
                 dotp 
                 = 
                 
                   
                     u 
                     * 
                     x 
                   
                   + 
                   
                     v 
                     * 
                     y 
                   
                   + 
                   
                     w 
                     * 
                     z 
                   
                 
               
               , 
               
                 
 
               
                
               
                 H 
                 = 
                 
                   
                     ( 
                     
                       
                         
                           a 
                           * 
                           
                             ( 
                             
                               
                                 v 
                                 * 
                                 v 
                               
                               + 
                               
                                 w 
                                 * 
                                 w 
                               
                             
                             ) 
                           
                         
                         + 
                         
                           u 
                           * 
                           
                             ( 
                             
                               
                                 
                                   - 
                                   b 
                                 
                                 * 
                                 v 
                               
                               - 
                               
                                 c 
                                 * 
                                 w 
                               
                               + 
                               dotp 
                             
                             ) 
                           
                         
                         + 
                         
                           ( 
                           
                             
                               
                                 - 
                                 c 
                               
                               * 
                               v 
                             
                             + 
                             
                               b 
                               * 
                               w 
                             
                             - 
                             
                               w 
                               * 
                               y 
                             
                             + 
                             
                               v 
                               * 
                               z 
                             
                           
                           ) 
                         
                       
                       , 
                       
                         
 
                       
                        
                       
                         
                           b 
                           * 
                           
                             ( 
                             
                               
                                 u 
                                 * 
                                 u 
                               
                               + 
                               
                                 w 
                                 * 
                                 w 
                               
                             
                             ) 
                           
                         
                         + 
                         
                           v 
                           * 
                           
                             ( 
                             
                               
                                 
                                   - 
                                   a 
                                 
                                 * 
                                 u 
                               
                               - 
                               
                                 c 
                                 * 
                                 w 
                               
                               + 
                               dotp 
                             
                             ) 
                           
                         
                         + 
                         
                           ( 
                           
                             
                               c 
                               * 
                               u 
                             
                             - 
                             
                               a 
                               * 
                               w 
                             
                             + 
                             
                               w 
                               * 
                               x 
                             
                             - 
                             
                               u 
                               * 
                               z 
                             
                           
                           ) 
                         
                       
                       , 
                       
                         
 
                       
                        
                       
                         
                           c 
                           * 
                           
                             ( 
                             
                               
                                 u 
                                 * 
                                 u 
                               
                               + 
                               
                                 v 
                                 * 
                                 v 
                               
                             
                             ) 
                           
                         
                         + 
                         
                           w 
                           * 
                           
                             ( 
                             
                               
                                 
                                   - 
                                   a 
                                 
                                 * 
                                 u 
                               
                               - 
                               
                                 b 
                                 * 
                                 v 
                               
                               + 
                               dotp 
                             
                             ) 
                           
                         
                         + 
                         
                           ( 
                           
                             
                               
                                 - 
                                 b 
                               
                               * 
                               u 
                             
                             + 
                             
                               a 
                               * 
                               v 
                             
                             - 
                             
                               v 
                               * 
                               x 
                             
                             + 
                             
                               u 
                               * 
                               y 
                             
                           
                           ) 
                         
                       
                     
                     ) 
                   
                   . 
                 
               
             
           
         
       
     
         [0000]    For a point x and a parameter t on the line x, it can be determined that 
         [0000]        x=Â+t ( H−A )  Eq. 22
 
         [0064]    Once the x and y axes are defined, the process  600  continues with the construction of an array of ‘x-y’ points on the plane at a block  608 . In this step, the array is constructed with points on the plane given by the equation: 
         [0000]        G   ij   =Â+iΔt ( H−Â )+ jΔt (   V − ( Â+iΔt ( H−Â )))  Eq. 23
 
         [0000]    for grid size parameter Δt and the range of i, j determined by the model size. 
         [0065]    Upon construction of the array, the process  600  may then generate an array of lines from the viewpoint through each array point in the plane at a block  610 . In this step, for each G ij , the process  600  generates a line L ij  consisting of points given by the equation: 
         [0000]        L   ij   =tG   ij   Eq. 24
 
         [0000]    for a parameter t. 
         [0066]    After generating the array of lines, the process  600  can find the surface of the 3D point-cloud at a block  612 . In this example, to perform the step, the process  600  finds the first intersection of each line L ij  with the model data (such as non-zero CT scan data) and/or finds the points P k  in the 3D point-cloud set which are within some distance E of each line L ij  but closest to the origin O. This data represents the surface point-cloud with respect to the viewpoint (e.g., the camera view). In this example, the distance d from a point x to a line L ij  is given by the equation: 
         [0000]    
       
         
           
             
               
                 
                   d 
                   = 
                   
                     
                        
                       
                         x 
                         × 
                         
                           ( 
                           
                             x 
                             - 
                             
                               G 
                               ij 
                             
                           
                           ) 
                         
                       
                        
                     
                     
                        
                       
                         G 
                         ij 
                       
                        
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   25 
                 
               
             
           
         
       
     
         [0000]    The solution for the index of the point-cloud data can be determined as: 
         [0000]    
       
         
           
             
               
                 
                   
                     argmin 
                     k 
                   
                   = 
                   
                     
                        
                       
                         
                           P 
                           k 
                         
                         × 
                         
                           ( 
                           
                             
                               P 
                               k 
                             
                             - 
                             
                               G 
                               ij 
                             
                           
                           ) 
                         
                       
                        
                     
                     
                        
                       
                         G 
                         ij 
                       
                        
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   26 
                 
               
             
           
         
       
     
         [0067]    It will be appreciated by one of ordinary skill in the art that while the process  600  is described as being well suited to find surface point-cloud date, the process  600  can also be utilized and extended to finding surface features within the object for such object as CT scans by considering the density with the scan itself. 
       Culling 3D Point-Clouds 
       [0068]    As will be appreciated, scanning complex structures can generate artifacts where adjacent points in the scanner data have significant difference in distance from the scanner. In the case of multiple scans this can lead to important surface data being hidden behind ‘stretched’ data from overlapping scans. For correct texture registration may be vital that these artifacts be removed. 
         [0069]    The collection of increasingly high resolution scanning data, and constraints due to current rendering hardware (especially the current choice of output device such as mobile devices), typically requires data reduction for the visualization of complex objects. The present disclosure provides intelligent processes for efficient point reduction for both of these cases while retaining important features such as object edges and relief features. 
         [0070]    For example, for full coverage, objects oftentimes need to be scanned from multiple viewpoints and each scan will generally overlap due to a desire to cover the entire object and restrictions on scanning locations. To merge multiple scans it is desirable to retain the optimal scans (those that have the highest resolution for a given common area) and remove artifacts connected by near and far points that appear adjacent in the ordering of the point-cloud. The examples provides herein provide a parameterized method of removing “poor” triangles (points) from the list. 
         [0071]    For example, referring to  FIGS. 7A and 7B , there are illustrated examples of artifacts generated by near and far objects appearing adjacent to each other in the point-cloud. In  FIG. 7A , an image  700  appears before any normalization and cleaning process. In the example of  FIG. 7B , an image  710  appears after the triangle areas are calculated and normalized and removed if they are larger than a given threshold. 
         [0072]    Still further, point-clouds acquired by scanning can oftentimes be extremely large. To distribute merged data to computers  20  and mobile devices  20 ′ via the network  14  typically requires that the data be compressed. The present disclosure includes example processes that can reduce the number of triangles (or points) in an “intelligent” manner such that important structural features, such as edges or relief features, are retained. For example, as illustrated in  FIGS. 8A and 8B , an image  800  shows an non-compressed image, while an image  810  shows an example of compression by removal of points while retaining important structural features such as edges. In addition, the described methods are efficient with a computationally linear time complexity. 
         [0073]    Yet further, mapping the image data acquired from camera enabled scanners requires the solution to a geometric mapping and scaling algorithm. The present disclosure provided herein includes processes to accomplish this automatically. This contrasts with current methods where each image is manually aligned with the point-cloud. As such, the manual approach found in prior art is impractical for multiple scans each with many images, such as for example, a Leica Scanstation II, which can oftentimes produce more than 100 images for a full 360 degree scan. An example image  900  showing the partial rendering of the Arch of Septimius Severus at the Roman Forum is illustrated in  FIG. 9 . 
       Convert the Point-Cloud to a Surface 
       [0074]    Without loss of generality the current disclosure assumes that the points are ordered in vertical (Z axis) lines with the zero vector representing points that are not included in the set (i.e. those removed by clipping). If this is not the case then the points must be ordered prior to analysis. Table 3 describes one example process used to find triangles that make up the surface to be textured. The example of Table 3 loops over all of the points and, for each point, tests the three other points adjacent to it to make a square (two triangles). If one point is missing we can form a single triangle and if more than one point is missing then no triangles are added. 
         [0000]    
       
         
               
               
             
           
               
                 TABLE 3 
               
               
                   
               
             
             
               
                   
                 Def CalculateMesh( ): 
               
               
                   
                  index=[ ] 
               
               
                   
                  For i in range(Horizontal−1): 
               
               
                   
                  For j in range(Vertical−1): 
               
               
                   
                   lineA=(i*Vertical)+j; 
               
               
                   
                   lineB=((i+1)*Vertical)+j; 
               
               
                   
                   count=4; 
               
               
                   
                   if Vertex[lineA]==Zero: 
               
               
                   
                    count-- 
               
               
                   
                   if Vertex[lineB]==Zero: 
               
               
                   
                    count-- 
               
               
                   
                   if Vertex[lineB+1]==Zero: 
               
               
                   
                    count-- 
               
               
                   
                   if Vertex[lineA+1]==Zero: 
               
               
                   
                    count-- 
               
               
                   
                   if count&lt;3): 
               
               
                   
                    continue 
               
               
                   
                   if Vertex[lineA]==Zero: 
               
               
                   
                    index.insert(Polygon(lineB,lineB+1,lineA+1)) 
               
               
                   
                    continue 
               
               
                   
                   if Vertex[lineB]==Zero: 
               
               
                   
                    index.insert(Polygon(lineA,lineB+1,lineA+1)) 
               
               
                   
                    continue 
               
               
                   
                   if Vertex[lineB+1]==Zero: 
               
               
                   
                    index.insert(Polygon(lineA,lineB,lineA+1)) 
               
               
                   
                    continue 
               
               
                   
                   if Vertex[lineA+1]==Zero: 
               
               
                   
                    index.insert(Polygon(lineA,lineB,lineB+1)) 
               
               
                   
                    continue 
               
               
                   
                  index.insert(Polygon(lineA,lineB,lineB+1)) 
               
               
                   
                  index.insert(Polygon(lineB+1,lineA+1,lineA)) 
               
               
                   
                 return index; 
               
               
                   
               
             
          
         
       
     
       Mesh Pruning to Remove “Poor” Triangles and Overlap 
       [0075]    Referring to  FIGS. 7A and 7B , when multiple scan locations are combined together and meshed, there are regions of the final model that have overlap from multiple scans. If these are mapped, the resolution of the scan (and hence the size of the triangles calculated) would be poor where the scanner is not directly aligned with the artifact. It would also be noticed artifacts in the form of very large (stretched) triangles where the angle that the scanner scanned from was not direct towards the model or where adjacent scan points have a large difference in distance from the scanner. These triangles are classified in the present disclosure as “poor” because to attain the highest resolution model, the present processes want as many small triangles as possible. 
         [0076]    To overcome this issue, the present examples calculate the average compensated size of a triangle and then prune all triangles that are greater than a threshold. This threshold is, in one example, based off of the average compensated size and can be tuned to an individual model if required to achieve the greatest quality end result. The compensated area is calculated as the area divided by the distance from the scanner. In some situations it may be desirable to use the reduction algorithm without using compensation. In one instance, given points A, B, C representing the vertices of the triangle it can be determined that the area by forming vectors AB and AC, then the magnitude of the cross product AB×AC is twice the area of the triangle. To compensate for distance it may be divided by the magnitude of A. 
         [0077]    In the examples illustrated in Tables 4 and 5 herein below, the disclosed processes compute the average triangle size (Table 4) and the “prune” any triangle above a predetermined threshold (Table 5). 
         [0000]    
       
         
               
               
             
           
               
                 TABLE 5 
               
               
                   
               
             
             
               
                   
                 def FindAverage(Verticies,Polygons): 
               
               
                   
                  average=0 
               
               
                   
                  for poly in Polygons: 
               
               
                   
                   bDiff=Verticies[poly.b]−Verticies[poly.a] 
               
               
                   
                   cDiff=Verticies[poly.c]−Verticies[poly.a] 
               
               
                   
                   size=CrossProduct(bDiff,cDiff).Magnitude( )*0.5 
               
               
                   
                   average+=retVal/Verticies[poly.a].Magnitude 
               
               
                   
                 return Absolute(average/len(Polygons)) 
               
               
                   
               
             
          
         
       
     
         [0000]    
       
         
               
               
             
           
               
                 TABLE 6 
               
               
                   
               
             
             
               
                   
                 def Prune(Threshold,Verticies,Polygons): 
               
               
                   
                  remaining=[ ] 
               
               
                   
                  for poly in Polygons: 
               
               
                   
                   bDiff=Verticies[poly.b]−Verticies[poly.a] 
               
               
                   
                   cDiff=Verticies[poly.c]−Verticies[poly.a] 
               
               
                   
                   size=CrossProduct(bDiff,cDiff).Magnitude( )*0.5 
               
               
                   
                   area=size/Verticies[poly.a].Magnitude 
               
               
                   
                   if area&lt;Threshold: 
               
               
                   
                    remaining.append(poly) 
               
               
                   
                  return remaining 
               
               
                   
               
             
          
         
       
     
       Point Reduction in O(N) 
       [0078]    Referring to  FIGS. 8A and 8B , to improve the speed of rendering mapped models, a process can be utilized to remove redundant points from the data set whilst keeping important features, such as edges. This process has time complexity of O(N). 
         [0079]    Due to the structure of the data set (a grid of points where holes are symbolized by a predefined “empty” point) the process can test four squares of increasing sizes to see if all of the points within the four squares face the same direction. If the points do face the same way within a threshold, the four squares can be reduced into a single square. To test if the points in the four squares face the same way, the process calculates the average normal vector for each point and then compares the center point to each point via a comparison metric. 
         [0080]    To test if a set of points is reducible, two comparison metrics are produced. The first comparison metric compares the angle between the center point and all eight surrounding points. If any of the surrounding points are greater than the threshold angle, then the process knows that the current set cannot be reduced and processing moves on. This method provides the most accurate final representation, as it does not remove any sets of points that do not all pass the test. This method provides reduction in triangles as shown in a plot  1000  illustrated in  FIG. 10 , which illustrates the remaining points after reduction where a center comparison is applied. 
         [0081]    The second comparison metric compares the square root of the sum of the squares of all of the angles between the center point and all eight surrounding points. If this value is less than the threshold then the set can be reduced. This provides a less accurate representation due to the way that the two norm calculation works, however it allows for a much greater reduction of points as shown a plot  1100  illustrated in  FIG. 11 , which shows the remaining points after reduction where two norm comparisons are applied. 
         [0082]    Examples of may be seen in Table 7. 
         [0000]    
       
         
               
             
           
               
                 TABLE 7 
               
               
                   
               
             
             
               
                 defPrunePoints(Threshold,Vertex,Polygons,Normal,Vertical,Horizontal,PointUses,Criteria): 
               
               
                  result=Polygons[:]pointUses=PointUses[:] 
               
               
                  step=2 
               
               
                  whilestep&lt;max(Horizontal,Vertical): 
               
               
                   hStep=step/2 
               
               
                   pUses=[0]*len(Vertex) 
               
               
                   for i in range(hStep,Horizontal,step): 
               
               
                    if i + hStep&gt;Horizontal: 
               
               
                    continue 
               
               
                   for j in range(hStep,Vertical,step): 
               
               
                    if j + hStep&gt;Vertical: 
               
               
                    continue 
               
               
                    lineA=((i−hStep)*Vertical)+j 
               
               
                    lineB=(i*Vertical)+j 
               
               
                    lineC=((i+hStep)*Vertical)+j 
               
               
                    if point Uses[lineB]==4: 
               
               
                    normals=[ 
               
               
                       Normal[lineA+hStep],Normal[lineB+hStep],Normal[lineC+hStep], 
               
               
                       Normal[lineA],Normal[lineB],normal[lineC], 
               
               
                       Normal[lineA−hStep],Normal[lineB−hStep],Normal[lineC−hStep] 
               
               
                       ] 
               
               
                    removable=true 
               
               
                    if Criteria == Center: 
               
               
                    for k in range(10): 
               
               
                     top=dot(normals[4],normals[k]) 
               
               
                     bottom=normals[4],Magnitude( )*normals[k].Magnitude( ) 
               
               
                     angle=acos(top/bottom)*(180.0/3.14159) 
               
               
                     if angle &gt;= Threshold: 
               
               
                      removable=falsebreak 
               
               
                     else: 
               
               
                      angle=0.0 
               
               
                    for k in range(10): 
               
               
                     ifk!=4: 
               
               
                      top=dot(normals[4],normals[k]) 
               
               
                      bottom=normals[4].Magnitude( )*normals[k].Magnitude( ) 
               
               
                      angle+=pow(acos(top/bottom)*(180.0/3.14159),2)angle=sqrt(angle)/8 
               
               
                    ifangle&gt;=Threshold: 
               
               
                     removable=falsebreak 
               
               
                    if removable: 
               
               
                    //RemoveBottomLeft 
               
               
                    result−=Polygon(lineA−hStep,lineB−hStep,lineB) 
               
               
                    result−=Polygon(lineB,lineA,lineA−hStep) 
               
               
                    //RemoveTopLeft 
               
               
                    result−=Polygon(lineA,lineB,lineB+hStep) 
               
               
                    result−=Polygon(lineB+hStep,lineA+hStep,lineA) 
               
               
                    //RemoveBottomRight 
               
               
                    result−=Polygon(lineB−hStep,lineC−hStep,lineC) 
               
               
                    result−=Polygon(lineC,lineB,lineB−hStep) 
               
               
                    //RemoveTopRight 
               
               
                    result−=Polygon(lineB,lineC,lineC+hStep) 
               
               
                    result−=Polygon(lineC+hStep,lineB+hStep,lineB) 
               
               
                    //CreateReplacementPoints 
               
               
                    result−=Polygon(lineA−hStep,lineC−hStep,lineC+hStep) 
               
               
                    result+=Polygon(lineC+hStep,lineA+hStep,lineA−hStep) 
               
               
                    //UpdateUsagesforNextSteppUses[lineA−hStep]++ 
               
               
                    pUses[lineA+hStep]++pUses[lineC−hStep]++pUses [lineC+hStep]++ 
               
               
                    pointUses=pUses[:]step+=step 
               
               
                 return result 
               
               
                   
               
             
          
         
       
     
         [0083]    It will be appreciated that the algorithm has an O(n) time complexity because every iteration works on a progressively smaller fraction of points, n/2, n/4, . . . , n/n, which is a geometric series that always increases but never actually reaches n. 
       Camera Enabled Scanners 
       [0084]    In this example of the present disclosure, there is provided a system and method of automatically mapping images generated by camera enabled scanners, to their associated point-clouds. Specifically, a number of the latest Laser Scanners incorporate a camera to provide pseudo images by coloring the point-cloud. The present disclosure may be used to map these images to the point-cloud to allow a more seamless rendering than can be obtained by colored points. An additional benefit is provided by allowing an intelligent point reduction algorithm to be used without degrading the rendered scene, which could not be used with the colored point representation without serious visual degradation. 
         [0085]    In the following example there is described the existence of a “focal sphere” that represents a sphere which contains the points at which the center of each image will reside (i.e. with the plane of the image tangental to the sphere), and where the image scaling is coincident with the scaling of the point-cloud data from the point of view of the camera. In short, this means that a vector from the camera location a through a given image pixel will intersect the point-cloud where the pixel light originated. The “focal sphere” is related to the camera FOV and is typically a fixed value. 
         [0086]    To find the location of an image center on the “focal sphere”, given rotation angles ψ, θ, φ for axes z, y, x, rotation matrices R z  (ψ), R y  (θ), R x (φ) are combines to give 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           R 
                           zyx 
                         
                         = 
                           
                          
                         
                           
                             
                               R 
                               z 
                             
                              
                             
                               ( 
                               ψ 
                               ) 
                             
                           
                            
                           
                             
                               R 
                               y 
                             
                              
                             
                               ( 
                               θ 
                               ) 
                             
                           
                            
                           
                             
                               R 
                               x 
                             
                              
                             
                               ( 
                               φ 
                               ) 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           [ 
                           
                             
                               
                                 
                                   cos 
                                    
                                   
                                       
                                   
                                    
                                   θ 
                                    
                                   
                                       
                                   
                                    
                                   cos 
                                    
                                   
                                       
                                   
                                    
                                   ψ 
                                 
                               
                               
                                 
                                   
                                     
                                       
                                         
                                           
                                             - 
                                             cos 
                                           
                                            
                                           
                                               
                                           
                                            
                                           θ 
                                            
                                           
                                               
                                           
                                            
                                           sin 
                                            
                                           
                                               
                                           
                                            
                                           ψ 
                                         
                                         + 
                                       
                                     
                                   
                                   
                                     
                                       
                                         sin 
                                          
                                         
                                             
                                         
                                          
                                         φ 
                                          
                                         
                                             
                                         
                                          
                                         sin 
                                          
                                         
                                             
                                         
                                          
                                         θ 
                                          
                                         
                                             
                                         
                                          
                                         cos 
                                          
                                         
                                             
                                         
                                          
                                         ψ 
                                       
                                     
                                   
                                 
                               
                               
                                 
                                   
                                     sin 
                                      
                                     
                                         
                                     
                                      
                                     φ 
                                      
                                     
                                         
                                     
                                      
                                     sin 
                                      
                                     
                                         
                                     
                                      
                                     ψ 
                                   
                                   + 
                                   
                                     cos 
                                      
                                     
                                         
                                     
                                      
                                     φ 
                                      
                                     
                                         
                                     
                                      
                                     sin 
                                      
                                     
                                         
                                     
                                      
                                     θ 
                                      
                                     
                                         
                                     
                                      
                                     cos 
                                      
                                     
                                         
                                     
                                      
                                     ψ 
                                   
                                 
                               
                             
                             
                               
                                 
                                   cos 
                                    
                                   
                                       
                                   
                                    
                                   θ 
                                    
                                   
                                       
                                   
                                    
                                   sin 
                                    
                                   
                                       
                                   
                                    
                                   ψ 
                                 
                               
                               
                                 
                                   
                                     
                                       
                                         
                                           cos 
                                            
                                           
                                               
                                           
                                            
                                           θ 
                                            
                                           
                                               
                                           
                                            
                                           cos 
                                            
                                           
                                               
                                           
                                            
                                           ψ 
                                         
                                         + 
                                       
                                     
                                   
                                   
                                     
                                       
                                         sin 
                                          
                                         
                                             
                                         
                                          
                                         φ 
                                          
                                         
                                             
                                         
                                          
                                         sin 
                                          
                                         
                                             
                                         
                                          
                                         θ 
                                          
                                         
                                             
                                         
                                          
                                         sin 
                                          
                                         
                                             
                                         
                                          
                                         ψ 
                                       
                                     
                                   
                                 
                               
                               
                                 
                                   
                                     
                                       - 
                                       sin 
                                     
                                      
                                     
                                         
                                     
                                      
                                     φ 
                                      
                                     
                                         
                                     
                                      
                                     cos 
                                      
                                     
                                         
                                     
                                      
                                     ψ 
                                   
                                   + 
                                   
                                     cos 
                                      
                                     
                                         
                                     
                                      
                                     φ 
                                      
                                     
                                         
                                     
                                      
                                     sin 
                                      
                                     
                                         
                                     
                                      
                                     θ 
                                      
                                     
                                         
                                     
                                      
                                     sin 
                                      
                                     
                                         
                                     
                                      
                                     ψ 
                                   
                                 
                               
                             
                             
                               
                                 
                                   
                                     - 
                                     sin 
                                   
                                    
                                   
                                       
                                   
                                    
                                   θ 
                                 
                               
                               
                                 
                                   sin 
                                    
                                   
                                       
                                   
                                    
                                   φ 
                                    
                                   
                                       
                                   
                                    
                                   cos 
                                    
                                   
                                       
                                   
                                    
                                   θ 
                                 
                               
                               
                                 
                                   cos 
                                    
                                   
                                       
                                   
                                    
                                   φ 
                                    
                                   
                                       
                                   
                                    
                                   cos 
                                    
                                   
                                       
                                   
                                    
                                   θ 
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   27 
                 
               
             
           
         
       
     
         [0000]    In the camera coordinates, the view is a vector in the z direction so without loss of generality a camera vector of C=(0, 0, 1) T  is chosen (where T denotes the transpose). The corresponding point on the “focal sphere” can then be found as 
         [0000]        C   fs   =CR   zyx   fs   Eq. 28
 
         [0000]    where fs is a scalar that scales the vector in the preceding terms. 
         [0087]    The normalized vector can then be found for future calculations as 
         [0000]    
       
         
           
             
               
                 
                   
                     C 
                     n 
                   
                   = 
                   
                     
                       C 
                       fs 
                     
                     
                        
                       
                         C 
                         fs 
                       
                        
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   29 
                 
               
             
           
         
       
     
         [0000]    Where ∥.∥ is the vector norm. 
         [0088]    To calculate texture coordinates, the example process finds  2  and  9  orthogonal axes in the plane tangential to the “focal sphere” at the location of the image center. In the camera coordinates the y-axis is vertical so without loss of generality the process forms a vertical vector V=(0, 1, 1) T  and finds the corresponding point on the plane as: 
         [0000]    
       
         
           
             
               
                 
                   
                     V 
                     p 
                   
                   = 
                   
                     
                       VR 
                       zyx 
                     
                      
                     
                       ( 
                       
                         fs 
                         
                           
                             VR 
                             zyx 
                           
                           · 
                           
                             C 
                             n 
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   30 
                 
               
             
           
         
       
     
         [0000]    where the bracketed term is a scalar that scales the vector in the preceding terms. 
         [0089]    The process then finds the orthogonal axes in the plane tangential to the Focal Sphere. For example, the process finds {circumflex over (x)} and ŷ orthogonal axes as: 
         [0000]    
       
         
           
             
               
                 
                   
                     y 
                     ^ 
                   
                   = 
                   
                     
                       
                         V 
                         p 
                       
                       - 
                       
                         C 
                         fs 
                       
                     
                     
                        
                       
                         
                           V 
                           p 
                         
                         - 
                         
                           C 
                           fs 
                         
                       
                        
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   31 
                 
               
             
           
         
       
     
         [0000]    where ∥.∥ is the vector norm. 
         [0090]    To find the {circumflex over (x)} the process rotates the vertical vector point V p  around the camera axis normal C n  by 90 degrees to give: 
         [0000]    
       
         
           
             
               
                 
                   
                     x 
                     ^ 
                   
                   = 
                   
                     
                       
                         H 
                         p 
                       
                       - 
                       
                         C 
                         fs 
                       
                     
                     
                        
                       
                         
                           H 
                           p 
                         
                         - 
                         
                           C 
                           fs 
                         
                       
                        
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   32 
                 
               
             
           
         
       
     
         [0000]    where, given substitutions V p =(x, y, z) T , C n =(a, b, c) T , 
         [0000]    
       
         
           
             
               
                 
                     
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   33 
                 
               
             
             
               
                 
                   
                     H 
                     p 
                   
                   = 
                   
                       
                     
                       [ 
                       
                         
                           
                             
                               
                                 a 
                                  
                                 
                                   ( 
                                   
                                     
                                       b 
                                       2 
                                     
                                     + 
                                     
                                       c 
                                       2 
                                     
                                   
                                   ) 
                                 
                               
                               + 
                               
                                 a 
                                  
                                 
                                   ( 
                                   
                                     
                                       - 
                                       
                                         b 
                                         2 
                                       
                                     
                                     - 
                                     
                                       c 
                                       2 
                                     
                                     + 
                                     ax 
                                     + 
                                     by 
                                     + 
                                     cz 
                                   
                                   ) 
                                 
                               
                               + 
                               
                                 ( 
                                 
                                   
                                     - 
                                     cb 
                                   
                                   + 
                                   cy 
                                   + 
                                   bz 
                                 
                                 ) 
                               
                             
                           
                         
                         
                           
                             
                               
                                 b 
                                  
                                 
                                   ( 
                                   
                                     
                                       a 
                                       2 
                                     
                                     + 
                                     
                                       c 
                                       2 
                                     
                                   
                                   ) 
                                 
                               
                               + 
                               
                                 v 
                                  
                                 
                                   ( 
                                   
                                     
                                       - 
                                       
                                         a 
                                         2 
                                       
                                     
                                     - 
                                     
                                       c 
                                       2 
                                     
                                     + 
                                     ax 
                                     + 
                                     by 
                                     + 
                                     cz 
                                   
                                   ) 
                                 
                               
                               + 
                               
                                 ( 
                                 
                                   ca 
                                   - 
                                   ac 
                                   + 
                                   cx 
                                   + 
                                   az 
                                 
                                 ) 
                               
                             
                           
                         
                         
                           
                             
                               
                                 c 
                                  
                                 
                                   ( 
                                   
                                     
                                       a 
                                       2 
                                     
                                     + 
                                     
                                       b 
                                       2 
                                     
                                   
                                   ) 
                                 
                               
                               + 
                               
                                 c 
                                  
                                 
                                   ( 
                                   
                                     
                                       - 
                                       
                                         a 
                                         2 
                                       
                                     
                                     - 
                                     
                                       b 
                                       2 
                                     
                                     + 
                                     ax 
                                     + 
                                     by 
                                     + 
                                     cz 
                                   
                                   ) 
                                 
                               
                               + 
                               
                                 ( 
                                 
                                   
                                     - 
                                     ba 
                                   
                                   + 
                                   
                                     a 
                                     2 
                                   
                                   - 
                                   bx 
                                   + 
                                   ay 
                                 
                                 ) 
                               
                             
                           
                         
                       
                       ] 
                     
                   
                 
               
               
                 
                     
                 
               
             
           
         
       
     
         [0091]    The example process then associates triangles with an image and calculate the corresponding texture coordinates for a surface, in particular, for a given point P i  on a triangle, and camera offset C o , the process can calculate a texture coordinate Ti as: 
         [0000]    
       
         
           
             
               
                 
                   
                     T 
                     i 
                   
                   = 
                   
                     [ 
                     
                       
                         
                           
                             
                               
                                 PT 
                                 
                                   i 
                                   · 
                                 
                               
                                
                               
                                 x 
                                 ^ 
                               
                             
                             + 
                             
                               1 
                               2 
                             
                           
                         
                       
                       
                         
                           
                             
                               
                                 PT 
                                 
                                   i 
                                   · 
                                 
                               
                                
                               
                                 y 
                                 ^ 
                               
                             
                             + 
                             
                               1 
                               2 
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   34 
                 
               
             
           
         
       
     
         [0000]    Where vector 
         [0000]    
       
         
           
             
               PT 
               i 
             
             = 
             
               
                 ( 
                 
                   
                     ( 
                     
                       
                         P 
                         i 
                       
                       - 
                       
                         C 
                         o 
                       
                     
                     ) 
                   
                    
                   
                     fp 
                     
                       
                         ( 
                         
                           
                             P 
                             i 
                           
                           - 
                           
                             C 
                             o 
                           
                         
                         ) 
                       
                       · 
                       
                         C 
                         n 
                       
                     
                   
                 
                 ) 
               
               - 
               
                 
                   C 
                   fp 
                 
                 . 
               
             
           
         
       
     
         [0092]    The example process then tests if either of the x, y components of T i  are less than 0 or greater than 1. In this event the point is outside the image and is not included in the surface. The test continues for all points in the triangle, if all points pass then they are stored with their texture coordinates in the surface and removed from the available points/triangle list. This process is then repeated for n images to produce n surfaces as described, for example, in the example listing in Table 8. 
         [0000]    
       
         
               
             
           
               
                 TABLE 8 
               
               
                   
               
             
             
               
                 def CreateRotationMatrix( xAngle, yAngle, zAngle ): 
               
               
                  matrix = [0.0] * 9 
               
               
                  b = sin( x_angle ) 
               
               
                  a = cos( x_angle ) 
               
               
                  d = sin( y_angle ) 
               
               
                  c = cos( y_angle ) 
               
               
                  f = sin( z_angle ) 
               
               
                  e = cos( z_angle ) 
               
               
                  matrix[0] = c * e 
               
               
                  matrix[1] = −( c * f ) 
               
               
                  matrix[2] = d 
               
               
                  matrix[3] = b * d * e + a * f 
               
               
                  matrix[4] = a * e − b * d * f 
               
               
                  matrix[5] = −( b * c ) 
               
               
                  matrix[6] = −( a * d * e) + b * f 
               
               
                  matrix[7] = b * e + a * d * f 
               
               
                  matrix[8] = a * c 
               
               
                  return matrix 
               
               
                 def CalcTextureMapping( TextureData, MeshIndex ): 
               
               
                  if len(TextureData) &lt; 6: 
               
               
                   print “Insufficient data for texture, ” + len(TextureData) + “\n” 
               
               
                   return 
               
               
                  Offset = Vector3(TextureData[3], TextureData[4], TextureData[5]) 
               
               
                  x_angle = −Angle.toRadians(TextureData[0]) 
               
               
                  y_angle = −Angle.toRadians(TextureData[1]) 
               
               
                  z_angle = −Angle.toRadians(TextureData[2]) 
               
               
                  matrix = CreateRotationMatrix( x_angle, y_angle, z_angle ) 
               
               
                  normal = Vector3( matrix[2], matrix[5], matrix[8] ).Normalised( ) 
               
               
                  sqrtaa = 2.2858996 
               
               
                  centerPointOnPlane = normal * sqrtaa 
               
               
                  verticalPoint = Vector3( 
               
               
                   matrix[1] + matrix[2], 
               
               
                   matrix[4] + matrix[5], 
               
               
                   matrix[7] + matrix[8] 
               
               
                  ).Normalised( ) 
               
               
                  lbDotNv = Vector3.Dot( verticalPoint, normal ) 
               
               
                  if lbDotNv == 0.0: 
               
               
                   return 
               
               
                  verticalPointOnPlane = verticalPoint * ( sqrtaa / lbDotNv ) 
               
               
                  x = verticalPointOnPlane.x( ) 
               
               
                  y = verticalPointOnPlane.y( ) 
               
               
                  z = verticalPointOnPlane.z( ) 
               
               
                  a = normal.x( ) 
               
               
                  b = normal.y( ) 
               
               
                  c = normal.z( ) 
               
               
                  u = a 
               
               
                  v = b 
               
               
                  w = c 
               
               
                  dotp1 = u * x + v * y + w * z 
               
               
                  xd = a * (v * v + w * w) 
               
               
                  xd += u * (−b * v − c * w + dotp1) 
               
               
                  xd += (−c * v + b * w − w * y + v * z) 
               
               
                  yd = b * (u * u + w * w) 
               
               
                  yd += v * (−a * u − c * w + dotp1) 
               
               
                  yd += (c * u − a * w + w * x − u * z) 
               
               
                  zd = c * (u * u + v * v) 
               
               
                  zd += w * (−a * u − b * v + dotp1) 
               
               
                  zd += (−b * u + a * v − v * x + u * y) 
               
               
                  horizontalPointOnPlane = Vector2( xd, yd, zd ) 
               
               
                  yVector = (verticalPointOnPlane − centerPointOnPlane).Normalised( ) 
               
               
                  xVector = (centerPointOnPlane − horizontalPointOnPlane).Normalised( ) 
               
               
                  Index = [ ] 
               
               
                  temptex = [ ] 
               
               
                  triangleOK = False 
               
               
                  for i in range(len(MeshIndex)): 
               
               
                   if i % 3 == 0: 
               
               
                    triangleOK = True 
               
               
                   point = Vertex[MeshIndex[i]] − Offset 
               
               
                   lbDotN = Vector3.Dot(point, normal) 
               
               
                   if lbDotN != 0.0: 
               
               
                    texInt = point * (sqrtaa / lbDotN) 
               
               
                    pVector = texlnt − centerPointOnPlane 
               
               
                    xCoord = Vector3.Dot(pVector, xVector) + 0.5 
               
               
                    yCoord = Vector3.Dot(pVector, yVector) + 0.5 
               
               
                    temptex[i % 3] = Vector2(xCoord, yCoord) 
               
               
                    if xCoord &lt; 0.0f | | xCoord &gt; 1.0f | | yCoord &lt; 0.0f | | yCoord &gt; 1.0f: 
               
               
                     triangleOK = False 
               
               
                   else: 
               
               
                    triangleOK = True 
               
               
                   if i % 3 == 2 and triangleOK: 
               
               
                    ii = i / 3 
               
               
                    for j in range(3): 
               
               
                     Index.push_back( MeshIndex[ii * 3 + j] ) 
               
               
                   
               
             
          
         
       
     
         [0093]    In one example, a number of the currently available laser scanners, for example the Leica C10, are fitted with an internal camera with which the points in the point-cloud can be colored to produce a pseudo-photographic effect. The resulting “image” is limited to the resolution of the scan rather than the image, and hence the user cannot observe the detail provided by traditional photographic sources. For example, to match a sixteen megapixel camera, the scanner would be required to scan sixteen million points in the area covered by a picture. For a 300 mm telephoto zoom lens this equates to a resolution of around 0.2 mm at a distance of 20 m, orders of magnitude better than current scanner technology. It is also an improvement to map the internal camera data to the point-cloud in order to build a surface on which to render the full resolution of the pictures. In addition, this allows the removal of redundant points, as described below, without degrading the rendered scene. This allows for fast and efficient rendering, even on mobile or internet connected devices. Unlike textured surfaces, removal of points is not possible in the “colored points” method, which limits the usability of data across a broad platform of devices. 
         [0094]    Images from internal cameras are typically acquired through the mirror system used to launch the laser beam. Post processing software, such as Leica Cyclone, can output not only the images, but also the metadata that describes the orientation and offset of the camera. For the Leica C10 camera the attitude is arranged in a gimbal format i.e. z,y,x rotation order in relation to the coordinate system of the scanner. The effective scaling can be determined from either the field of view (FOV) of the camera, or by matching some non-central image point to the point-cloud. In the invention described herein we find the “focal sphere” where the center point of each image must touch (and the image plane is then tangential to) in order to be projected onto the points in the point-cloud with the correct scaling. For the example Leica Scanstation II described herein, this was found to be a sphere of diameter 2.2858996m. 
       Robotic Tripods 
       [0095]    In this yet another example use of the present invention, the process may be utilized to map multiple images acquired from robotic tripods, such as a GigaPan, to scan data. In one example, this process may be achieved in three steps; finding the ‘focal sphere’ where a tangential image has unity dimension, calculating the image center and normal vectors, and calculating the spherical coordinates of each image. 
         [0096]    The example process first finds the “focal sphere” radius, fp, representing the distance from the point of acquisition of the images to a sphere where the image size would be unity. For far objects this would be equal to the lens focal length F divided by the image sensor vertical size d. In practice, for nearer objects S 1 , we have: 
         [0000]    
       
         
           
             
               
                 
                   
                     1 
                     F 
                   
                   = 
                   
                     
                       1 
                       
                         S 
                         1 
                       
                     
                     + 
                     
                       1 
                       
                         S 
                         2 
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   35 
                 
               
             
             
               
                 
                   fp 
                   = 
                   
                     
                       
                         ( 
                         
                           
                             F 
                             
                               - 
                               1 
                             
                           
                           - 
                           
                             S 
                             1 
                             
                               - 
                               1 
                             
                           
                         
                         ) 
                       
                       
                         - 
                         1 
                       
                     
                     d 
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   36 
                 
               
             
           
         
       
     
         [0000]    Here F can be found from the image EXIF information, e.g. 300 mm for a typical telephoto lens. For a full frame DSLR camera d will be around 24 mm. S 1  is found by taking the norm of one of the object 3D points. 
         [0097]    For the angle of view the process can then determine that: 
         [0000]    
       
         
           
             
               
                 
                   fp 
                   = 
                   
                     1 
                     
                       2 
                        
                       
                           
                       
                        
                       tan 
                        
                       
                         α 
                         2 
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   37 
                 
               
             
           
         
       
     
         [0000]    for α the angle of view. 
         [0098]    All mapping calculations require the process to find fp. If the camera parameters are known the process can calculate the focal sphere fp directly. Otherwise the process needs to use known coincident points in both 3D-space and the 2D images and calculate fp. Two example methods are described herein. 
         [0099]    In the first example method, if fp is not known the process can calculate it by choosing a non-central point on the image, PP, that is coincident with a point-cloud point DP. Given a point at the center of the image CP=( 0 . 5 ,  0 . 5 ) T  the process can use the sine rule to find 
         [0000]    
       
         
           
             
               
                 
                   
                     fp 
                     = 
                     
                       
                          
                         
                           CP 
                           - 
                           PP 
                         
                          
                       
                        
                       
                         ( 
                         
                           
                             cos 
                              
                             
                                 
                             
                              
                             α 
                           
                           
                             
                               1 
                               - 
                               
                                 
                                   cos 
                                   2 
                                 
                                  
                                 α 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                    
                   
                     
 
                   
                    
                   where 
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   38 
                 
               
             
             
               
                 
                   
                     cos 
                      
                     
                         
                     
                      
                     α 
                   
                   = 
                   
                     
                       DP 
                       · 
                       
                         C 
                         n 
                       
                     
                     
                        
                       DP 
                        
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   39 
                 
               
             
           
         
       
     
         [0100]    In the second example method, given two 3D points PA and PB with corresponding points on the image with vectors A and B with respect to the image center (normalized to picture dimensions), with length a and b respectively. The angle between the vectors satisfies the equation 
         [0000]    
       
         
           
             
               
                 
                   
                     cos 
                      
                     
                         
                     
                      
                     ψ 
                   
                   = 
                   
                     
                       PA 
                       · 
                       PB 
                     
                     
                       
                          
                         PA 
                          
                       
                        
                       
                          
                         PB 
                          
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   40 
                 
               
             
           
         
       
     
         [0101]    As such, the process defines the vector to the center of the image as PC with length fp, then 
         [0000]    
       
         
           
             
               
                 
                   
                     cos 
                      
                     
                         
                     
                      
                     ψ 
                   
                   = 
                   
                     
                       
                         ( 
                         
                           PC 
                           + 
                           A 
                         
                         ) 
                       
                       · 
                       
                         ( 
                         
                           PC 
                           + 
                           B 
                         
                         ) 
                       
                     
                     
                       
                         
                           
                             PC 
                             · 
                             PC 
                           
                           + 
                           
                             a 
                             2 
                           
                         
                       
                        
                       
                         
                           
                             PC 
                             · 
                             PC 
                           
                           + 
                           
                             b 
                             2 
                           
                         
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   41 
                 
               
             
             
               
                 
                   = 
                   
                     
                       
                         PC 
                         · 
                         PC 
                       
                       + 
                       
                         PC 
                         · 
                         B 
                       
                       + 
                       
                         PC 
                         · 
                         A 
                       
                       + 
                       
                         A 
                         · 
                         B 
                       
                     
                     
                       
                         
                           
                             PC 
                             · 
                             PC 
                           
                           + 
                           
                             a 
                             2 
                           
                         
                       
                        
                       
                         
                           
                             PC 
                             · 
                             PC 
                           
                           + 
                           
                             b 
                             2 
                           
                         
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   42 
                 
               
             
           
         
       
     
         [0000]    
       
         
           
             
               
                 
                   
                       
                   
                    
                   
                     
                       = 
                       
                         
                           
                             f 
                             p 
                             2 
                           
                           + 
                           
                             A 
                             · 
                             B 
                           
                         
                         
                           
                             
                               ( 
                               
                                 
                                   f 
                                   p 
                                   2 
                                 
                                 + 
                                 
                                   a 
                                   2 
                                 
                               
                               ) 
                             
                              
                             
                               ( 
                               
                                 
                                   f 
                                   p 
                                   2 
                                 
                                 + 
                                 
                                   b 
                                   2 
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                      
                     
                       
 
                     
                      
                     
                         
                     
                      
                     
                       which 
                        
                       
                           
                       
                        
                       yields 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   43 
                 
               
             
             
               
                 
                   
                       
                   
                    
                   
                     
                       
                         cos 
                         2 
                       
                        
                       ψ 
                     
                     = 
                     
                       
                         
                           ( 
                           
                             
                               f 
                               p 
                               2 
                             
                             + 
                             
                               A 
                               · 
                               B 
                             
                           
                           ) 
                         
                         2 
                       
                       
                         
                           ( 
                           
                             
                               f 
                               p 
                               2 
                             
                             + 
                             
                               a 
                               2 
                             
                           
                           ) 
                         
                          
                         
                           ( 
                           
                             
                               f 
                               p 
                               2 
                             
                             + 
                             
                               b 
                               2 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   44 
                 
               
             
             
               
                 
                   
                       
                   
                    
                   
                     
                       = 
                       
                         
                           
                             f 
                             p 
                             4 
                           
                           + 
                           
                             2 
                              
                             
                                 
                             
                              
                             
                               A 
                               · 
                               
                                 Bf 
                                 p 
                                 2 
                               
                             
                           
                           + 
                           
                             
                               ( 
                               
                                 A 
                                 · 
                                 B 
                               
                               ) 
                             
                             2 
                           
                         
                         
                           
                             f 
                             p 
                             4 
                           
                           + 
                           
                             
                               ( 
                               
                                 
                                   a 
                                   2 
                                 
                                 + 
                                 
                                   b 
                                   2 
                                 
                               
                               ) 
                             
                              
                             
                               f 
                               p 
                               2 
                             
                           
                           + 
                           
                             
                               a 
                               2 
                             
                              
                             
                               b 
                               2 
                             
                           
                         
                       
                     
                      
                     
                       
 
                     
                      
                     
                         
                     
                      
                     then 
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   45 
                 
               
             
             
               
                 
                   
                     
                       
                         ( 
                         
                           
                             
                               cos 
                               2 
                             
                              
                             ψ 
                           
                           - 
                           1 
                         
                         ) 
                       
                        
                       
                         f 
                         p 
                         4 
                       
                     
                     + 
                     
                       
                         ( 
                         
                           
                             
                               cos 
                               2 
                             
                              
                             
                               ψ 
                                
                               
                                 ( 
                                 
                                   
                                     a 
                                     2 
                                   
                                   + 
                                   
                                     b 
                                     2 
                                   
                                 
                                 ) 
                               
                             
                           
                           - 
                           
                             2 
                              
                             
                                 
                             
                              
                             
                               A 
                               · 
                               B 
                             
                           
                         
                         ) 
                       
                        
                       
                         f 
                         p 
                         2 
                       
                     
                     + 
                     
                       
                         cos 
                         2 
                       
                        
                       ψ 
                        
                       
                           
                       
                        
                       
                         a 
                         2 
                       
                        
                       
                         b 
                         2 
                       
                     
                     - 
                     
                       
                         ( 
                         
                           A 
                           · 
                           B 
                         
                         ) 
                       
                       2 
                     
                   
                   = 
                   0 
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   46 
                 
               
             
           
         
       
     
         [0000]    which can be solved using standard quadratic techniques known to one of ordinary skill in the art. 
         [0102]    To calculate the image center and normal vectors, the process requires the vector to the center of at least one image be known to align the image data to the scan data. In this example, at least one of three methods may be used to determine this. 
         [0103]    In a first example, the center and normal vectors are calculated given two arbitrary points on the image. To find the normal vector, the process can find the center vector by solving the equation set 
         [0000]    
       
         
           
             
               
                 
                   
                     PC 
                     · 
                     PA 
                   
                   = 
                   
                     
                       fp 
                       
                         
                           
                             fp 
                             2 
                           
                           + 
                           
                             a 
                             2 
                           
                         
                       
                     
                      
                     
                        
                       PA 
                        
                     
                      
                     fp 
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   47 
                 
               
             
             
               
                 
                   
                     PC 
                     · 
                     PB 
                   
                   = 
                   
                     
                       fp 
                       
                         
                           
                             fp 
                             2 
                           
                           + 
                           
                             b 
                             2 
                           
                         
                       
                     
                      
                     
                        
                       PB 
                        
                     
                      
                     fp 
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   48 
                 
               
             
             
               
                 
                   
                      
                     PC 
                      
                   
                   = 
                   fp 
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   49 
                 
               
             
           
         
       
     
         [0000]    then the normal vector N is 
         [0000]    
       
         
           
             
               
                 
                   N 
                   = 
                   
                     PC 
                      
                     
                       1 
                       
                          
                         PC 
                          
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   50 
                 
               
             
           
         
       
     
         [0000]    It will be noted that this result does not guarantee (or require) that the image is vertical. 
         [0104]    In a second example, the center and normal vectors are calculated given one vector and the focal sphere. In this example, the process first finds the vector in the image plane P AP coinciding with the known vector PA 
         [0000]    
       
         
           
             
               
                 
                   PAP 
                   = 
                   
                     PA 
                      
                     
                       
                         
                           
                             fp 
                             2 
                           
                           + 
                           
                             a 
                             2 
                           
                         
                       
                       
                          
                         PA 
                          
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   51 
                 
               
             
           
         
       
     
         [0105]    Then, the process finds a vertical vector in the image plane PVP coinciding with the y-coordinate of the known vector, noting that it shares a plane in the z-axis with this vector. This yields equations 
         [0000]        PVP.P AP=fp   2   +A   y   2   Eq. 52
 
         [0000]      ∥ PVP×PAP∥=A   x ( fp   2   +A   y   2 )  Eq. 53
 
         [0000]        PVP   z   =PAP   z   Eq. 54
 
         [0000]    where A. is the coordinate length in the image plane for PA. These equations can be solved simultaneously for PVP. As will be noted, this yields two results, the correct one can be selected using the identity 
         [0000]      ∥ PVP∥=fp   2   +A   y   2 .  Eq.55
 
         [0000]    Resulting in three equations in PC 
         [0000]        PC.P AP=fp   2   Eq. 56
 
         [0000]        PC.P VP=fp   2   Eq. 57
 
         [0000]      ∥ PC∥=fP   2   Eq. 58
 
         [0000]    which can be solved simultaneously for PC. Again, this yields two results. The correct result can be determined by considering the value of the z component in relation to the z component of PA utilizing the process of Table 9, assuming z(1) is the first result for the z-coordinate and z(2) the second. 
         [0000]    
       
         
               
               
             
           
               
                 TABLE 9 
               
               
                   
               
             
             
               
                   
                 //coords reversed as from TLHC, so A(2) &lt; 0 means PAP above center! 
               
               
                   
                 if(A(2)&lt;0){ 
               
               
                   
                  //if zccord positive then PAP or PVP z coord &gt; PC z coord 
               
               
                   
                  if(PAP(3) &gt; z(1)){ 
               
               
                   
                   PVP_z = z(1); 
               
               
                   
                  }else{ 
               
               
                   
                   PVP(3) = z(2); 
               
               
                   
                  } 
               
               
                   
                 }else{ 
               
               
                   
                  //if zccord negative then PAP or PVP z coord &lt; PC z coord 
               
               
                   
                  if(PAP(3) &lt; z(1)){ 
               
               
                   
                   PVP(3) = z(1); 
               
               
                   
                  }else{ 
               
               
                   
                   PVP(3) = z(2); 
               
               
                   
                  } 
               
               
                   
                 } 
               
               
                   
               
             
          
         
       
     
         [0106]    As previously noted, the normal vector N is then 
         [0000]    
       
         
           
             
               
                 
                   N 
                   = 
                   
                     PC 
                      
                     
                       
                         1 
                         
                            
                           PC 
                            
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   59 
                 
               
             
           
         
       
     
         [0000]    In this case the image will be orientated vertically. 
         [0107]    In the third example method, the approximate relative orientation is determined with one vector, given the focal sphere. In this example given the focal sphere fp the elevation of one of the points PA or PB and the y coordinate of that point on the image the process can determine the z and ratio x/y of the center point on the image. 
         [0000]    
       
         
           
             
               
                 
                   
                     θ 
                     PA 
                   
                   = 
                   
                     
                       sin 
                       
                         - 
                         1 
                       
                     
                      
                     
                       ( 
                       
                         
                           - 
                           
                             PA 
                             z 
                           
                         
                         
                            
                           PA 
                            
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   60 
                 
               
             
             
               
                 
                   
                     θ 
                     DIFF 
                   
                   = 
                   
                     
                       tan 
                       
                         - 
                         1 
                       
                     
                      
                     
                       ( 
                       
                         
                           IM 
                           y 
                         
                         fp 
                       
                       ) 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   61 
                 
               
             
             
               
                 
                   
                     PC 
                     z 
                   
                   = 
                   
                     
                       sin 
                        
                       
                         ( 
                         
                           
                             θ 
                             PA 
                           
                           - 
                           
                             θ 
                             DIFF 
                           
                         
                         ) 
                       
                     
                      
                     fp 
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   62 
                 
               
             
           
         
       
     
         [0000]    where P C z  is the center point z element, IM y  is the y coordinate of the vector PA on the image. Similarly, 
         [0000]    
       
         
           
             
               
                 
                   
                     φ 
                     PA 
                   
                   = 
                   
                     
                       tan 
                       
                         - 
                         1 
                       
                     
                      
                     
                       ( 
                       
                         
                           PA 
                           x 
                         
                         
                           PA 
                           y 
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   63 
                 
               
             
             
               
                 
                   
                     φ 
                     DIFF 
                   
                   = 
                   
                     
                       tan 
                       
                         - 
                         1 
                       
                     
                      
                     
                       ( 
                       
                         
                           IM 
                           x 
                         
                         fp 
                       
                       ) 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   64 
                 
               
             
             
               
                 
                   
                     
                       PC 
                       x 
                     
                     
                       PC 
                       y 
                     
                   
                   = 
                   
                     
                       tan 
                        
                       
                         ( 
                         
                           
                             φ 
                             PA 
                           
                           - 
                           
                             φ 
                             DIFF 
                           
                         
                         ) 
                       
                     
                      
                     
                       
                         cos 
                          
                         
                           ( 
                           
                             
                               θ 
                               PA 
                             
                             - 
                             
                               θ 
                               DIFF 
                             
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   65 
                 
               
             
           
         
       
     
         [0108]    The process can then use Eqn.(47) to find the x coordinate 
         [0000]    
       
         
           
             
               
                 
                   
                     PC 
                     x 
                   
                   = 
                   
                     
                       
                         
                           PC 
                           x 
                         
                         
                           PC 
                           y 
                         
                       
                        
                       
                         ( 
                         
                           
                             
                               
                                 fp 
                                 2 
                               
                                
                               
                                  
                                 PA 
                                  
                               
                             
                             
                               
                                 
                                   fp 
                                   2 
                                 
                                 + 
                                 
                                   a 
                                   2 
                                 
                               
                             
                           
                           - 
                           
                             
                               PA 
                               z 
                             
                              
                             
                               PC 
                               z 
                             
                           
                         
                         ) 
                       
                     
                     
                       
                         PA 
                         y 
                       
                       + 
                       
                         
                           PA 
                           x 
                         
                          
                         
                           
                             PC 
                             x 
                           
                           
                             PC 
                             y 
                           
                         
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   66 
                 
               
             
           
         
       
     
         [0000]    and y coordinate 
         [0000]    
       
         
           
             
               
                 
                   
                     PC 
                     y 
                   
                   = 
                   
                     - 
                     
                       
                         
                           
                             
                               PA 
                               x 
                             
                              
                             
                               PC 
                               x 
                             
                           
                           - 
                           
                             
                               
                                 fp 
                                 2 
                               
                                
                               
                                  
                                 PA 
                                  
                               
                             
                             
                               
                                 
                                   fp 
                                   2 
                                 
                                 + 
                                 
                                   a 
                                   2 
                                 
                               
                             
                           
                           + 
                           
                             
                               PA 
                               z 
                             
                              
                             
                               PC 
                               z 
                             
                           
                         
                         
                           PA 
                           y 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   67 
                 
               
             
           
         
       
     
         [0000]    It will be noted that this result does not guarantee that the image is vertical. 
         [0109]    Once the focal sphere and the image center and normal vectors are calculated, the process can then calculate the image sphere coordinates. In this instance, the process can calculate the spherical coordinates of the main image normal vector. In particular, Given the normal vector {circumflex over (n)} the azimuth (φ) and elevation (θ) can be determined by: 
         [0000]    
       
         
           
             
               
                 
                   θ 
                   = 
                   
                     
                       sin 
                       
                         - 
                         1 
                       
                     
                      
                     
                       ( 
                       
                         
                           n 
                           ^ 
                         
                         z 
                       
                       ) 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   68 
                 
               
             
             
               
                 
                   φ 
                   = 
                   
                     
                       tan 
                       
                         - 
                         1 
                       
                     
                      
                     
                       ( 
                       
                         
                           
                             n 
                             ^ 
                           
                           x 
                         
                         
                           n 
                           y 
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   69 
                 
               
             
           
         
       
     
         [0000]    where the x, y, z suffix represents the individual components of the 3 space vector. 
         [0110]    The process can also calculate the elevation and Azimuth steps for overlapping images. For instance, Given that the overlap of two adjacent images is o then the associated angle step γ θ  in elevation is: 
         [0000]    
       
         
           
             
               
                 
                   
                     γ 
                     θ 
                   
                   = 
                   
                     2 
                      
                     
                         
                     
                      
                     
                       
                         tan 
                         
                           - 
                           1 
                         
                       
                        
                       
                         ( 
                         
                           
                             1 
                             - 
                             o 
                           
                           
                             2 
                              
                             
                                 
                             
                              
                             fp 
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   70 
                 
               
             
           
         
       
     
         [0111]    For the associated angle step γ φ  in azimuth the process can take account of the increase in horizontal overlap with elevation angle. Because the overlap distance is proportional to the radius of the circle that represents the sphere cross section at the given elevation, fp cos(θ) for sphere radius fp, it can be determined that: 
         [0000]    
       
         
           
             
               
                 
                   
                     γ 
                     φ 
                   
                   = 
                   
                     2 
                      
                     
                         
                     
                      
                     
                       
                         
                           tan 
                           
                             - 
                             1 
                           
                         
                          
                         
                           ( 
                           
                             
                               1 
                               - 
                               σ 
                             
                             
                               2 
                                
                               
                                   
                               
                                
                               fp 
                                
                               
                                   
                               
                                
                               cos 
                                
                               
                                   
                               
                                
                               θ 
                             
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                    
                   71 
                 
               
             
           
         
       
     
         [0112]    Given the spherical coordinates for the center of each image, relative to the scan data, and the focal sphere diameter allows the process to use the previous methods described herein. Here surfaces are generated and textured with the images to generate a query-able merged data set that can be viewed and manipulated in a virtual 3D-space or printed using emerging 3D color printers. In one embodiment of the invention 3D data is combined with 2D surface images acquired from the same device. 
         [0113]    Referring to  FIGS. 12A and 12B , an example scan of a statue, namely a statute at Bond Hall at the University of Notre Dame has been textured with a photograph of the same statue, taken from the same point as the scanner. A resultant surface  1210  generated from the point-cloud data can be seen in  FIG. 12A  and a resulting textured surface  1220  can be seen in  FIG. 12B . 
         [0114]    Still further, referring to  FIGS. 13A and 13B , an example CT scan of a beetle was obtained and a 3D surface point-cloud  1310  was generated from the CT scan data as described hereinabove. A photographic image was used to texture the resulting surface using the processes described herein, and an example resulting image  1320  can be seen in  FIG. 13B . 
         [0115]    Although certain example methods and apparatus have been described herein, the scope of coverage of this patent is not limited thereto. On the contrary, this patent covers all methods, apparatus, and articles of manufacture fairly falling within the scope of the appended claims either literally or under the doctrine of equivalents.