1. Technical Field
The present disclosure relates generally to software used for modeling and design of interior or exterior spaces.
2. Background and Relevant Art
As computerized systems have increased in popularity, so has the range of applications that incorporate computational technology. Computational technology now extends across a broad range of applications, including a wide range of productivity and entertainment software. Indeed, end users can now find computational technology and related software in a wide range of generic applications that are suited for many environments, as well as fairly industry-specific software.
Some examples of industry-specific application programs include those known as Computer-aided design (i.e., “CAD”) programs, such as AUTOCAD. In general, CAD programs provide a user with the ability to draw lines or blocks (which represent groupings of lines that represent objects) on a CAD user interface, where those lines represent various “design entities” or “design elements” in a plan view of a raw design space. To manage each of the various design entities created through the user interface, CAD programs typically incorporate a record-based database.
In general, the record-based database can also be referred to as a “linear” database, since it includes a set of sequential records whose relationships are based primarily on the sequence/moment in time at which those records were created. For example, when a user creates a line (i.e., a “design entity”) in a CAD user interface, the data related to that line (such as type, position, etc.) are stored in a newly-created “record” in the record-based (linear) database. When a user creates the next line (or circle, etc.) in the CAD user interface, the corresponding linear (or sequential) database creates a new record in the linear database. Since the main relationship between these records is primarily based on sequence, each record includes little or no relation to other records within the database that were created much earlier or later in the sequence.
In addition, CAD programs generally limit the user's ability to layout or specify furniture with only rudimentary geometry-based applications. In conventional geometry-based application programs, the user can place geometric “blocks” representing the product in space, and the application program constrains placement of the block relative to other blocks (representative of other furniture) based solely on the relation of geometric features of each block in a “plan view.” For example, in a conventional design program, a user can use a “plan view” interface of the program to place a work surface block immediately next to a wall panel block. The user can then use corner points, end points, mid-points or similar for proper alignment (i.e., to connect the corner point of the work surface block with the end point of the wall panel block).
Conventional software can also implement sub-routines within the software to automate the location of these blocks in relation to each other's geometric features. Unfortunately, however, there is typically no true product intelligence within conventional geometry-based design software. In most cases, for example, the user will still need to provide information regarding which products may be used together, how those products behave together, and which connection components are required to attach the products together. The often means that the user/designer needs to personally remember every part and piece related to the products placed in the context of the layout. If the user desires to change the elements associated with a block, such change may be laborious, and often requires the user starting the design over from the start.
Furthermore, the representative views that the geometry-based design program provides to the user of the products are typically rudimentary and subject to interpretation. While some application programs may provide three-dimensional views, if they exist at all, such programs typically do not provide such views with the appropriate colors, finishes, materials, shadowing, shading, transparency or reflectivity. Rather, to get such views, a user will often need to initialize or export one view from the geometry-based application to yet another separate rendering software application. Even then, such separate rendering software provides only one view at a time, whereby the user selects a specific viewing angle and then captures that view in a single static image, with applied finishes, materials, shadowing, shading and reflectivity. Thus, the user may still need to manually replicate any change or request in one view to another view in another application, which results in repeat rendering of those additional views. Furthermore, more complicated renderings that could allow a “fly through” navigation-type experience can take conventional rendering applications minutes, hours, or even days to render.
By contrast, there are also now design applications that incorporate non-sequential, three-dimensional (“3D”) relationships for records, such as object-oriented software programs used for design functions. Generally, an object-oriented database represents each entity as an intelligent object block (analogous to a linear database's record). In contrast with the record in a record-based database, which is basically just a collection of data, each object block can be thought of as an independent program of computer-executable instructions in addition to certain user-entered data. The independent, intelligent nature of object entities can enable a wide range of functionality not otherwise available to records or linear databases.
Unfortunately, traditional conventional object-oriented design programs still have other limitations when importing data from linear records since the user will still need to supply finishes, materials, shadowing, shading, and reflectivity with respect to the imported CAD blocks. One such limitation can be due to the otherwise advantages of the object-oriented application itself. For example, if a CAD-based design comprised design choices that were not currently available in inventory (e.g., drawing a blue colored glass table when only black or brown wood grain tables are available), the object-oriented software might not render the user's design as drawn in the CAD program without warning. Alternatively, and also potentially without warning, the object-oriented software might correct the design element to appear in some way not intended by the user.
Accordingly, conventional records-based and object-oriented-based design or rendering programs present a number of issues that can be addressed.
Implementations of the present invention overcome one or more problems in the art with systems, methods, and computer program products configured to instantly render user-drawn CAD design elements such as blocks and/or lines (in a CAD application program) as one or more design elements in a separate, three-dimensional interface. This rendering is a three dimensional rendering, enabling the user to move, rotate, “fly-through” or edit the one or more design elements in the three-dimensional interface. This can allow the user to effectively view a CAD-based design in full context, even if there may be certain errors or inconsistencies in the design. In addition, in at least one implementation, the user can also convert the design elements to intelligent objects, and allow the system to warn or automatically correct for any errors or deficiencies in the design. This can allow the user to correlate the user's design changes in the CAD interface with real-world considerations, ensuring accuracy of the user's viewing experience, as well as of ordering and manufacturing requests.
For example, at least one implementation of a computer-implemented method of using an object-oriented design program to instantly render user designs made in a CAD program can involve identifying one or more user requests to render in a three-dimensional user interface one or more design elements created in a separate CAD user interface. The method can also involve receiving one or more CAD design elements that represent one or more CAD blocks and/or lines created by the user in the CAD user interface. In addition, the method can involve receiving one or more files that identify features of the design elements that the user selected in the CAD user interface. Furthermore, the method can involve automatically displaying the CAD blocks as three-dimensional design elements in the three-dimensional user interface using previously-generated rendering instructions.
In addition to the foregoing, an additional or alternative method of using an object-oriented design program to instantly render user designs made in the CAD program can involve identifying one or more user requests to render in a three-dimensional user interface one or more design elements created in a separate CAD user interface. In this case, the one or more user requests further indicate that no intelligent objects are to be created. The method can also involve importing from the CAD program into the object-oriented program one or more CAD blocks and/or lines that represent one or more design elements created by the user in the CAD user interface.
In addition, the method can involve importing a separate feature file comprising user-selected features corresponding to the one or more design elements in the one or CAD blocks and/or lines. Furthermore, the method can involve automatically displaying the CAD blocks as three-dimensional design elements in the three-dimensional user interface using previously-generated rendering instructions. Still further, the method can involve displaying in the three-dimensional user interface at least one of the user-selected features from the feature file as being non-modifiable, and another of the user-selected features from the feature file as being modifiable.
Additional features and advantages of exemplary implementations of the invention will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by the practice of such exemplary implementations. The features and advantages of such implementations may be realized and obtained by means of the instruments and combinations particularly pointed out in the appended claims. These and other features will become more fully apparent from the following description and appended claims, or may be learned by the practice of such exemplary implementations as set forth hereinafter.
In order to describe the manner in which the above-recited and other advantages and features of the invention can be obtained, a more particular description of the invention briefly described above will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings. Understanding that these drawings depict only typical embodiments of the invention and are not therefore to be considered to be limiting of its scope, the invention will be described and explained with additional specificity and detail through the use of the accompanying drawings in which:
The present invention extends to systems, methods, and computer program products configured to instantly render user-drawn CAD design elements such as blocks and/or lines (in a CAD application program) as one or more design elements in a separate, three-dimensional interface. This rendering is a three dimensional rendering, enabling the user to move, rotate, “fly-through” or edit the one or more design elements in the three-dimensional interface. This can allow the user to effectively view a CAD-based design in full context, even if there may be certain errors or inconsistencies in the design. In addition, in at least one implementation, the user can also convert the design elements to intelligent objects, and allow the system to warn or automatically correct for any errors or deficiencies in the design. This can allow the user to correlate the user's design changes in the CAD interface with real-world considerations, ensuring accuracy of the user's viewing experience, as well as of ordering and manufacturing requests.
As will be understood more fully herein, these and other advantages are realized at least in part since implementations of the present invention provide one or more mechanisms for automatically and instantly rendering record-based data (e.g., linear or sequential database entries representing graphical entities in a CAD application), as well as correlating such data to detailed, object-oriented entities (or “intelligent software objects”). This translation/rendering/linking/correlating can be accomplished and mediated at least in part through the use of one or more intermediate interface 107 components configured to correlate record-based changes with object entities in an object-oriented database. Linking to the object entities, in turn, allows a CAD interface to take advantage of some of the more complex features of an object-oriented system, such as producing, viewing and modifying three-dimensional (3D) views of a design. In one implementation, the object-oriented design application program is implemented using a JAVA-based programming language.
The use of object entities (e.g., JAVA-based object entities) through a separate or intermediate interface 107 allows a user to work within a record-based CAD application, within an object-oriented application, or within a third application (or corresponding output files) linked to the CAD application. In one implementation, such as understood more fully with respect to
As a preliminary matter, reference herein to “CAD” or “AUTOCAD” is meant to describe programs that incorporate general design functionality using linear or record-based databases, rather than a specific reference to any particular existing product. In addition, although any database entry might be thought of as a “record” on some level, the term “record-based” when referring herein to an application program or database will refer to application programs or databases that primarily use sequential or “linear” database entry/modification mechanisms, rather than object-oriented database entries. As previously mentioned, these types of database entries (i.e., records) are not only typically sequential, but also tend to include only basic information about a design entity, such as design entity type, design entity position, or the like. In contrast to object-oriented applications that use object entities, therefore, a “record” can be understood herein as a passive data entry, while an “object block” can be understood herein as an active data entry with added intelligence.
In any event,
In this example,
In contrast with
In general, one will appreciate that there are a number of different ways that a user can correlate design entity 120 between record-based database 113 and object-oriented database 117. For example, a user could select object status item 115 before drawing any design entities, and set that as a default for all design entities until deselecting the object status item 115. Since each following design entity would have the same object state of “on,” the intermediate interface 107 would create or modify both a record and an object entity corresponding to the design entity during creation, modification, or other form of update.
In other cases, however, the user could select particular design entities to have a particular object state of “on” or “off.” In particular, the user could select object status item 115 during or after creating design entity 120, and/or make an additional selection (not shown) indicating that design entity 120 should have an object state of “on.” In such a case, intermediate interface 107 could recognize that creation or modification of design entity involves modifications to an object entity in database 117 as well as a record in database 113, while creation or modification of design entity 125 involves modifications only to a record in database 113. In still further cases, one or more selection items (not shown) can be provided for the user to select conversion of all design entity records (or all records, design entity or not) from database 113 to database 117. This would involve any one or more of copying, transferring, or moving data from database 113 to database 117 to ensure proper correlation, or total substitution of record-based database 113 with object-oriented database 117.
In addition to the foregoing,
The intermediate interface 107 then sends message 140 to object-oriented database 117 not only to create an object (133) for design entity 120, but also to include the additional details requested, such as that the design entity represents a wall, or even other details about the wall structure, color, design, texture, materials, etc. Ordinarily, however, these and other details might not be included in the typical record for a design entity in a CAD application. For example,
In a typical CAD-based application, the user might be free to draft this extension to design entity 125 because the records 130, 135 of database 113 do not resolve the conflict, and only implement or record the user's drawing selection. By contrast,
Accordingly,
One will appreciate that this corrective ability can be applied to a wide number of design entities drawn or made by a user in CAD user interface 105. For example, the object entities of database 117 could correct a situation where the user drew the components of a chair and placed those components inadvertently on top of a wall. In such a case, the object entity might cause the CAD user interface 105 to automatically move the chair to a more appropriate position, if not deleting the user's placement altogether.
In addition to the foregoing, the object entities of database 117 can be used to correct or implement user selections made in views other than the CAD user interface 105. For example,
In general, the three-dimensional format of interface 109 is generated at least partly from the more detailed information contained in the object entities (e.g., 133, 137) of database 117. For example, the object entities of database 117 can contain information not only of size or position, but also of texture, color, width or gauge, number or types of mounting components, as well as three-dimensional representations of the types of materials used in the wall (e.g., glass, wood, dry wall, etc.), the lighting at a particular angle, etc. The object entities can also include information about pricing for various components, or other forms of information deemed applicable for each design entity.
As such, the user can then navigate around or through any of these design entities, in various angles and degrees of proximity, and even select pricing or other details instantly with respect to a particular design entity. The user can also make any selections or changes to the three-dimensional views (or two-dimensional views, as appropriate) of each design entity, and have those reflected seamless in all entries for each corresponding record or object, regardless of database (113 and/or 117).
In this case, for example,
Accordingly,
For example,
There may be a number of reasons why a user may want to create renderings without initially creating intelligent object entities (or “objects”). For example, the user may desire to simply render CAD drawings in 3D in a quick, efficient manner, and not worry that some of the color or physical arrangements of elements may not be possible. That is, and as previously mentioned, the intelligent objects (e.g., 133, 137) are generally configured to automatically move or update a drawing in accordance with actual, real-world variables (e.g., tables cannot be placed on top of walls, chairs that come only in black or white cannot be colored in blue, etc.). Thus, without creating objects, the present software can ensure that it renders the user's designs in the three-dimensional interface (as in
Along these lines,
In one implementation, the CAD program (which provides CAD interface 105) maintains these records in separate files and/or in separate databases. Nevertheless, one will appreciate that this is not required, and the CAD program can maintain such information in a single database with single records not only for design choices but for design element features. In any event,
For example,
Although, in some implementations, rendering/determining module 210 could draw the CAD design elements in 3D in interface 109 on this information alone, such drawings would not comprise the context of finishes that the user selected in CAD interface 105, and thus would be inexact. In at least one implementation, for example, the CAD design elements represent components of specific dimensions with specific attributes, and both dimensions and applicable attributes must be recognized and correctly applied by the present invention, in order to represent the components properly in the rendering. Thus,
In at least one implementation, the features 203 in message 240 can comprise a Standard Information File (or SIF), although any number of file formats may be used to transmit design element feature information.
In any event, and upon receipt of messages/communications 235, 240,
By way of explanation, these unintelligent (or dumb) objects 410a, 410b, etc. merely maintain information in object-oriented database 117 with regard to the CAD design elements and corresponding features that import interface 215 received in messages 235, 240. In contrast with the intelligent objects otherwise described herein (e.g.,
Referring again to
Thus, rather than render each particular CAD design entity (CAD block and/or CAD line) as the interface 107 receives it from the corresponding CAD program, rendering/determining module 210 can merely combine pre-rendered instructions as a set of new rendering instructions for display. For example, upon receipt of communications 235, 240 from the CAD program, rendering/determination module 210 queries object features database 230 (e.g., via one or more messages 213) to determine the existence of the user's requested CAD design elements, as well as the user-selected features for the CAD design elements. In some cases, this can involve coordinating CAD-entity information with standard stock-keeping unit (SKU) information maintained by either or both of the CAD program and the object-oriented program corresponding to intermediate interface 107. Either way,
Rendering module 210 can then receive one or more answers (e.g., messages 217) that either include the requested rendering instructions, or indicate that the instructions do not exist. Notably, in this case, object-features database 230 will not determine whether specific design elements should (or can) include specific features, such as in inventory. Thus, even if a particular table does not allow for a wood grain finish, at least one implementation of the invention allows object features database 230 (and/or object-oriented database 117, if applicable) to still provide rendering instructions for the particular table and wood grain finish since the users selected it.
In addition, if the rendering/determining module 210 does not identify rendering instructions for a particular CAD design entity/element or feature, there are a number of ways intermediate interface 107 can proceed. For example, rendering determining module 210 can render the CAD design element without the unavailable feature, or otherwise render the design element with a closely matching feature. Similarly, if the design element (e.g., table, chair, etc.) does not exist at all in the intermediate interface 107 inventor, rendering/determining module 109 could draw the remaining design elements in interface 109, but place either an error message or the like in place of the requested design element.
In any event,
As previously mentioned, intermediate interface 107 only created unintelligent objects 410a, 410b, and thus did not create any automatically and continually resolvable intelligent objects (e.g., 410a′, 410b′, etc.) for the imported CAD design element(s) and corresponding features (e.g., messages 235, 240). Nevertheless, intermediate interface 107 can still provide the user the ability to still move, navigate around, or otherwise modify the user's design in 3D user-interface 109 at least in part. In at least one implementation, for example, intermediate interface 107 provides the user, through 3D user interface 109, the ability to change feature information on the design elements such as color, finish, or other style choices. In this implementation, the intermediate interface 107 might also be configured to disallow changes to such things as dimension, or additions/deletions of design elements into the drawing.
Along these lines,
As previously mentioned, however, this particular implementation of displaying the user's design choices are simply for viewing purposes in the three dimensional view, and such changes are thus not replicated either to object-oriented database 117 or back to CAD interface 105. For example, the features toolbar 220 that user-interface 109 provides to the user in
In some additional implementations, the 3D user interface 109 could still allow a user to add or replace different design elements, even those of different dimensions, even though only unintelligent objects 410a, 410b are being used. In such cases the user would have to move or rotate the design elements in the user interface 109 himself in order to accommodate any changes (e.g., dimensional changes), as the objects 410a, 410b would not automatically resolve and make such changes for the user (in contrast with objects 410a′ and 410b′ discussed below). Thus, in these types of implementations using unintelligent objects, therefore, the intermediate interface 107 provides a relatively limited, but at the same time rich, viewing experience of the user's CAD designs.
By contrast, and for the user to be able to change all the features of the table, specifically the dimensions of the table, as well as modify, delete, or add design elements in the 3D user interface 109 in automatically resolvable ways, the user will need to create an intelligent object for each the design elements. For example,
Along these lines,
In addition, intermediate interface 107 can also add one or more links between these linked objects and one or more reference libraries 420 and/or to the object features database 230. In this case, the links can ensure that changes in the reference library 420 and/or object features database 230 are automatically resolved or replicated in the intelligent objects 410a′, 410b′, and vice-versa. In still further implementations, intermediate interface 107 can add additional computer-executable routines that cause each intelligent object 410′ to not only identify changes in other objects or libraries, but also to react to such changes in an automatic, continual way.
However generated or created,
Referring again to
For example,
In at least one implementation, intelligent object 410a′ further correlates the new positioning information with data from a reference library, which stores rules and options for each type of design element. Accordingly, due to the various relationships the intelligent object 410a′ has with other objects for the design elements in user-interface 109, and based on the information in reference library 420, intelligent object 410a′ automatically updates the table to remove three table legs and add brackets. In particular,
In addition to the foregoing, using intelligent objects 410′ (also 133, 137,
For example, at the moment the user positions table 126 against walls 120 and 121, the automatic determinations by intelligent object 410a′ can also be instantly reflected in an updated parts list. Along these lines,
As such, a user could alternatively make edits in the parts list (or a Bill of Materials, Order Proposal, reports etc.) and have this instantly reflected in the 3D user interface 109. Upon selecting the 3D user interface 109, any changes that the user made in the parts list would thus be automatically reflected in the rendering of the 3D user interface. For example, if the color blue were available for the table 126, and the user edited the color from black to blue in the parts list, the user interface 109 would automatically be updated to show the table in the color blue, where appropriate. The user can then send any such parts lists (or Bill of Materials, Order Proposals, etc.) on to manufacturing, as appropriate.
In still other cases, the user can generate one or more output files (not shown) that are accurate, and can be used to update the features database 200, corresponding third-party application(s) managing the database, and/or the CAD program managing CAD user interface 105. As with generating a parts list, for example, the user can similarly ask intermediate interface 107 to generate one or more output files based on the current drawing in interface 109 that the user can pass to another entity. The intermediate interface 107 (e.g., via interface 215) can then pass the output file directly to features database 200, and/or to the third-party application program that manages features database 200. Then, when using CAD user interface 105 again, the CAD design elements (e.g., including any CAD blocks of CAD lines)
Accordingly,
For example,
Along these lines,
In addition,
Furthermore,
In addition to the foregoing,
In addition,
Furthermore,
Still further,
In view of the foregoing, one will appreciate that the components and modules of the present invention can capture product knowledge automatically rather than requiring the user to remember and continually cross-reference and update various applications. This automatic calculation and correction by the software can minimize human error, and further allow for immediate design change capability without rework, reduction or elimination of manual audit process, and automation of drawing and document creation processes. Such error reduction is further enhanced not only by automated corrections, but also due to accurate 3D validation of the design, and further allowing more sales due to the faster time to delivery and powerful visual lure of the 3D representation. For at least these and other reasons contained herein, implementations of the present invention provide a wide range of advantages in both designing, rendering, viewing, and finalizing designs, regardless whether the designs were created using the more conventional records-based drawing/design programs (e.g., CAD programs).
The embodiments of the present invention may comprise a special purpose or general-purpose computer including various computer hardware, as discussed in greater detail below. Embodiments within the scope of the present invention also include computer-readable media for carrying or having computer-executable instructions or data structures stored thereon. Such computer-readable media can be any available media that can be accessed by a general purpose or special purpose computer.
By way of example, and not limitation, such computer-readable media can comprise RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to carry or store desired program code means in the form of computer-executable instructions or data structures and which can be accessed by a general purpose or special purpose computer. When information is transferred or provided over a network or another communications connection (either hardwired, wireless, or a combination of hardwired or wireless) to a computer, the computer properly views the connection as a computer-readable medium. Thus, any such connection is properly termed a computer-readable medium. Combinations of the above should also be included within the scope of computer-readable media.
Computer-executable instructions comprise, for example, instructions and data which cause a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions. Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims.
The present invention may be embodied in other specific forms without departing from its spirit or essential characteristics. The described embodiments are to be considered in all respects only as illustrative and not restrictive. The scope of the invention is, therefore, indicated by the appended claims rather than by the foregoing description. All changes that come within the meaning and range of equivalency of the claims are to be embraced within their scope.
This application is a U.S. National Stage Application corresponding to PCT/CA2009/000183, filed on Feb. 13, 2009, entitled “Rendering and Modifying CAD Design Entities in Object-Oriented Applications,” which claims the benefit of priority to U.S. Provisional Application No. 61/028,399, filed on Feb. 13, 2008, entitled “Automated Conversion of CAD-Based Blocks to Intelligent Rendered Objects in Object-Oriented Design Software.” This application is also a continuation-in-part of U.S. patent application Ser. No. 11/577,302, filed on Aug. 16, 2008, entitled “Integration of Object-Oriented Design Software with Record-Based CAD Software,” which is a 371 US National Stage Application corresponding to PCT Application No. CA07/000241, filed on Feb. 16, 2007, which claims priority to U.S. Provisional Patent Application No. 60/774,096, filed on Feb. 16, 2006. The entire content of each of the aforementioned applications is incorporated herein by reference.
Filing Document | Filing Date | Country | Kind | 371c Date |
---|---|---|---|---|
PCT/CA2009/000183 | 2/13/2009 | WO | 00 | 6/24/2009 |
Publishing Document | Publishing Date | Country | Kind |
---|---|---|---|
WO2009/100538 | 8/20/2009 | WO | A |
Number | Name | Date | Kind |
---|---|---|---|
5111392 | Malin | May 1992 | A |
5255207 | Cornwell | Oct 1993 | A |
5293479 | Quintero et al. | Mar 1994 | A |
5514232 | Burns | May 1996 | A |
5555357 | Fernandes et al. | Sep 1996 | A |
5572639 | Gantt | Nov 1996 | A |
5576965 | Akasaka et al. | Nov 1996 | A |
5588098 | Chen et al. | Dec 1996 | A |
5625827 | Krause | Apr 1997 | A |
5684713 | Asada et al. | Nov 1997 | A |
5740341 | Oota | Apr 1998 | A |
5764518 | Collins | Jun 1998 | A |
5870771 | Oberg | Feb 1999 | A |
5894310 | Arsenault et al. | Apr 1999 | A |
5977982 | Lauzon | Nov 1999 | A |
5995107 | Berteig | Nov 1999 | A |
6014503 | Nagata | Jan 2000 | A |
6020885 | Honda | Feb 2000 | A |
6037945 | Loveland | Mar 2000 | A |
6253167 | Matsuda | Jun 2001 | B1 |
6292810 | Richards | Sep 2001 | B1 |
6401237 | Ishikawa | Jun 2002 | B1 |
6459435 | Eichel | Oct 2002 | B1 |
6466239 | Ishikawa | Oct 2002 | B2 |
6493679 | Rappaport | Dec 2002 | B1 |
6509906 | Awe et al. | Jan 2003 | B1 |
6662144 | Normann et al. | Dec 2003 | B1 |
6690981 | Kawachi | Feb 2004 | B1 |
6701288 | Normann | Mar 2004 | B1 |
6721684 | Saebi | Apr 2004 | B1 |
6772168 | Ardoin et al. | Aug 2004 | B2 |
6888542 | Clauss | May 2005 | B1 |
6922701 | Ananian et al. | Jul 2005 | B1 |
6971063 | Rappaport | Nov 2005 | B1 |
6985832 | Saebi | Jan 2006 | B2 |
6999102 | Felser et al. | Feb 2006 | B2 |
7019753 | Rappaport | Mar 2006 | B2 |
7042440 | Pryor et al. | May 2006 | B2 |
7062454 | Giannini | Jun 2006 | B1 |
7062722 | Loberg | Jun 2006 | B1 |
7080096 | Imamura | Jul 2006 | B1 |
7085697 | Rappaport | Aug 2006 | B1 |
7096173 | Rappaport | Aug 2006 | B1 |
7155228 | Rappaport | Dec 2006 | B2 |
7171208 | Rappaport | Jan 2007 | B2 |
7200639 | Yoshida | Apr 2007 | B1 |
7216092 | Weber | May 2007 | B1 |
7243054 | Rappaport | Jul 2007 | B2 |
7246044 | Imamura | Jul 2007 | B2 |
7246045 | Rappaport | Jul 2007 | B1 |
7249005 | Loberg | Jul 2007 | B2 |
7266768 | Ferlitsch | Sep 2007 | B2 |
7277572 | MacInnes | Oct 2007 | B2 |
7277830 | Loberg | Oct 2007 | B2 |
7299168 | Rappaport | Nov 2007 | B2 |
7299416 | Jaeger | Nov 2007 | B2 |
7340383 | Mayuzumi | Mar 2008 | B2 |
7353192 | Ellis | Apr 2008 | B1 |
7587302 | Arvin | Sep 2009 | B2 |
7643966 | Adachi | Jan 2010 | B2 |
7661959 | Green | Feb 2010 | B2 |
7676348 | Okada | Mar 2010 | B2 |
7788068 | Mangon | Aug 2010 | B2 |
7814436 | Schrag | Oct 2010 | B2 |
7822584 | Saebi | Oct 2010 | B1 |
7823074 | Takemura | Oct 2010 | B2 |
7856342 | Kfouri | Dec 2010 | B1 |
7877237 | Saebi | Jan 2011 | B1 |
7996756 | Eilers | Aug 2011 | B2 |
8108267 | Varon | Jan 2012 | B2 |
8132123 | Schrag | Mar 2012 | B2 |
8134553 | Saini | Mar 2012 | B2 |
8185219 | Gilbert | May 2012 | B2 |
8244025 | Davis | Aug 2012 | B2 |
8314799 | Pelletier | Nov 2012 | B2 |
8352218 | Balla | Jan 2013 | B2 |
8462147 | Sugden | Jun 2013 | B2 |
8499250 | Wetzer | Jul 2013 | B2 |
8508539 | Vlietinck | Aug 2013 | B2 |
8510672 | Loberg | Aug 2013 | B2 |
20010024211 | Kudukoli | Sep 2001 | A1 |
20010047250 | Schuller | Nov 2001 | A1 |
20010047251 | Kemp | Nov 2001 | A1 |
20020010589 | Nashida | Jan 2002 | A1 |
20020069221 | Rao | Jun 2002 | A1 |
20020083076 | Wucherer et al. | Jun 2002 | A1 |
20020085041 | Ishikawa | Jul 2002 | A1 |
20020091739 | Ferlitsch | Jul 2002 | A1 |
20020093538 | Carlin | Jul 2002 | A1 |
20020144204 | Milner | Oct 2002 | A1 |
20020188678 | Edecker | Dec 2002 | A1 |
20020196285 | Sojoodi | Dec 2002 | A1 |
20040012542 | Bowsher | Jan 2004 | A1 |
20040027371 | Jaeger | Feb 2004 | A1 |
20040098691 | Teig | May 2004 | A1 |
20040117746 | Narain et al. | Jun 2004 | A1 |
20040145614 | Takagaki | Jul 2004 | A1 |
20040153824 | Devarajan | Aug 2004 | A1 |
20040204903 | Saebi | Oct 2004 | A1 |
20040205519 | Chapel | Oct 2004 | A1 |
20050041028 | Coutts | Feb 2005 | A1 |
20050065951 | Liston | Mar 2005 | A1 |
20050071135 | Vredenburgh et al. | Mar 2005 | A1 |
20050081161 | MacInnes et al. | Apr 2005 | A1 |
20060028695 | Knighton et al. | Feb 2006 | A1 |
20060041842 | Loberg | Feb 2006 | A1 |
20060174209 | Barros | Aug 2006 | A1 |
20060206623 | Gipps et al. | Sep 2006 | A1 |
20060271378 | Day | Nov 2006 | A1 |
20070088704 | Bourne | Apr 2007 | A1 |
20070115275 | Cook et al. | May 2007 | A1 |
20070168325 | Bourne | Jul 2007 | A1 |
20070180425 | Storms et al. | Aug 2007 | A1 |
20070188488 | Choi | Aug 2007 | A1 |
20070204241 | Glennie et al. | Aug 2007 | A1 |
20070219645 | Thomas et al. | Sep 2007 | A1 |
20070240049 | Rogerson et al. | Oct 2007 | A1 |
20070250295 | Murray | Oct 2007 | A1 |
20070260432 | Okada | Nov 2007 | A1 |
20070271870 | Mifsud et al. | Nov 2007 | A1 |
20070294622 | Sterner | Dec 2007 | A1 |
20080036769 | Coutts | Feb 2008 | A1 |
20080052618 | McMillan | Feb 2008 | A1 |
20080143884 | Foster | Jun 2008 | A1 |
20080275674 | Reghetti et al. | Nov 2008 | A1 |
20080282166 | Fillman | Nov 2008 | A1 |
20080303844 | Reghetti et al. | Dec 2008 | A1 |
20080309678 | Reghetti et al. | Dec 2008 | A1 |
20090113349 | Zohar | Apr 2009 | A1 |
20090119039 | Banister et al. | May 2009 | A1 |
20090138826 | Barros | May 2009 | A1 |
20090148050 | Reghetti et al. | Jun 2009 | A1 |
20090210487 | Westerhoff et al. | Aug 2009 | A1 |
20090248184 | Steingart | Oct 2009 | A1 |
20090273598 | Reghetti et al. | Nov 2009 | A1 |
20100017733 | Barros | Jan 2010 | A1 |
20100121614 | Reghetti et al. | May 2010 | A1 |
20100122196 | Wetzer | May 2010 | A1 |
20100138762 | Reghetti et al. | Jun 2010 | A1 |
20100185514 | Glazer | Jul 2010 | A1 |
20110078169 | Sit | Mar 2011 | A1 |
20110169826 | Elsberg | Jul 2011 | A1 |
20110258573 | Wetzer | Oct 2011 | A1 |
20110320966 | Edecker | Dec 2011 | A1 |
20120005353 | Edecker | Jan 2012 | A1 |
20120331422 | High | Dec 2012 | A1 |
Number | Date | Country |
---|---|---|
1098244 | Sep 2001 | EP |
1098244 | Sep 2001 | EP |
EP1204046 | May 2002 | JP |
WO9003618 | Apr 1990 | WO |
WO9322741 | Nov 1993 | WO |
WO02075597 | Sep 2002 | WO |
WO2005033985 | Apr 2005 | WO |
WO2006018744 | Feb 2006 | WO |
WO2007093060 | Aug 2007 | WO |
2007106873 | Sep 2007 | WO |
2006018740 | Feb 2009 | WO |
2009100538 | Aug 2009 | WO |
Entry |
---|
Josie Wernecke; Title: The Inventor Mentor: Programming Object Oriented 3D Graphics with Open Inventor; Release 2; Date: Jun. 19, 1997; Published on Web Site: www.cs.ualberta.cal-. |
Office Action Mailed Jul. 29, 2009, U.S. Appl. No. 11/204,421. |
International Search Report and Opinion on PCT/CA2007/000241, mailed May 15, 2007. |
International Search Report and Opinion on PCT/CA2009/000190, mailed Jun. 5, 2009. |
International Search Report and Opinion on PCT/CA2009/000183, mailed Jun. 9, 2009. |
International Search Report and Opinion on PCT/CA2009/000311, mailed Jul. 30, 2009. |
Office Action Mailed Aug. 18, 2010, U.S. Appl. No. 11/577,302. |
International Search Report & Written Opinion for PCT/US2010/058092 dated Jul. 27, 2011. |
USPTO, Office Action in U.S. Appl. No. 12/444,886, mailed Oct. 27, 2011, 24 pages. |
USPTO, Office Action in U.S. Appl. No. 12/444,890, mailed Oct. 27, 2011, 30 pages. |
Chan, et al.: “Design of a Walkthrough System for Indoor Environments from Floor Plans”; Proceedings of the 1998 IEEE Conference on Information Visualization, Jul. 29-31, 1998, pp. 50-57. |
Office Action Mailed Oct. 18, 2006, U.S. Appl. No. 11/204,419. |
Office Action Mailed Oct. 19, 2006, U.S. Appl. No. 11/204,420. |
Office Action Mailed Nov. 28, 2007, U.S. Appl. No. 11/204,421. |
Office Action Mailed Aug. 11, 2008, U.S. Appl. No. 11/204,421. |
Office Action Mailed Dec. 23, 2008, U.S. Appl. No. 11/204,421. |
Advisory Action Mailed Mar. 31, 2009, U.S. Appl. No. 11/204,421. |
Advisory Action Mailed May 15, 2009, U.S. Appl. No. 11/204,421. |
Marir F et al: “OSCONCAD: a model-based CAD system integrated with computer applications”, Proceedings of the International Construction IT Conference, vol. 3, 1998. |
EPO Search Report for EP07701791 dated Aug. 21, 2012. |
USPTO, Office Action in U.S. Appl. No. 12/444,886, mailed Aug. 16, 2012. |
International Search Report for PCT/CA2009000190 mailed Apr. 12, 2012. |
Blythe, Rise of the Graphics Processor, IEEE, 2008. |
U.S. Office of Personnel Management, Clear Cache, IE, 2007. |
Wang, Intellectual Property Protection in Collaborative Design through Lean information Modeling and Sharing , 2006. |
Lea, Community Place Architecture and Performance, 2007. |
Autodesk, Maya 8.5 Shading, 2007. |
CRC, Final Report Collaboration Platform. 2009. |
Mental Images GmbH, RealityServer Functional Overview White Paper, 2007. |
Rozansk, Software Systems Architecture Working With Stakeholders Using Viewpoints and Perspectives, 2008. |
Sony, Community Place Conductor 2.0 Users Manual, 1998. |
Vasko, Collaborative Modeling of Web Applications for Various Stakeholders, 2009. |
Gross M D: “Why can't CAD be more like Lego? CKB, a program for building constructions kits”, Automation in Construction, Elsevier Science Publishers, Amsterdam, NL, vol. 5, No. 4, Oct. 1, 1996 pp. 285-300, XP004072247, ISSN: 0926-5805, DOI:10.1016/S0926-5805(96)00154-9. |
European Search Report—Application No./ Patent No. 09719352.8-1960 / 2252951 PCT/CA2009000311. |
Number | Date | Country | |
---|---|---|---|
20100268513 A1 | Oct 2010 | US |
Number | Date | Country | |
---|---|---|---|
61028399 | Feb 2008 | US | |
60774096 | Feb 2006 | US |
Number | Date | Country | |
---|---|---|---|
Parent | 11577302 | US | |
Child | 12444893 | US |