/// <summary>
 /// The action taken on application initialization.
 /// </summary>
 /// <param name="sender">The sender.</param>
 /// <param name="eventArgs">The event args.</param>
 private void OnApplicationInitialized(object sender, EventArgs eventArgs)
 {
    SingleServerService service = ExternalServiceRegistry.GetService(ExternalServices.BuiltInExternalServices.IFCImporterService) as SingleServerService;
    if (service != null)
    {
       Importer importer = new Importer();
       service.AddServer(importer);
       service.SetActiveServer(importer.GetServerId());
    }
    else
       throw new InvalidOperationException("Failed to get IFC importer service.");
 }
Example #2
0
        /// <summary>
        /// Import an IFC file into a given document for Reference only.
        /// </summary>
        /// <param name="document">The host document for the import.</param>
        /// <param name="origFullFileName">The full file name of the document.</param>
        /// <param name="options">The list of configurable options for this import.</param>
        public void ReferenceIFC(Document document, string origFullFileName, IDictionary <String, String> options)
        {
            // We need to generate a local file name for all of the intermediate files (the log file, the cache file, and the shared parameters file).
            string localFileName = ImporterIFCUtils.GetLocalFileName(document, origFullFileName);

            if (localFileName == null)
            {
                throw new InvalidOperationException("Could not generate local file name for: " + origFullFileName);
            }

            // An early check, based on the options set - if we are allowed to use an up-to-date existing file on disk, use it.
            // It is possible that the log file may have been created in CreateImporter above,
            // if it is used by an external developer.
            if (TheLog == null)
            {
                m_ImportLog = IFCImportLog.CreateLog(localFileName, "log.html", !m_ImportOptions.DisableLogging);
            }

            Document originalDocument = document;
            Document ifcDocument      = null;

            if (TheOptions.Action == IFCImportAction.Link)
            {
                string linkedFileName = IFCImportFile.GetRevitFileName(localFileName);

                ifcDocument = LoadOrCreateLinkDocument(originalDocument, linkedFileName);
            }
            else
            {
                ifcDocument = originalDocument;
            }

            bool useCachedRevitFile = DocumentUpToDate(ifcDocument, localFileName);

            // In the case where the document is already opened as a link, but it has been updated on disk,
            // give the user a warning and use the cached value.
            if (!useCachedRevitFile && ifcDocument.IsLinked)
            {
                useCachedRevitFile = true;
                Importer.AddDelayedLinkError(BuiltInFailures.ImportFailures.IFCCantUpdateLinkedFile);
            }

            if (!useCachedRevitFile)
            {
                m_ImportCache = IFCImportCache.Create(ifcDocument, localFileName);

                // Limit creating the cache to Link, but may either remove limiting or make it more restrict (reload only) later.
                if (TheOptions.Action == IFCImportAction.Link)
                {
                    TheCache.CreateExistingElementMaps(ifcDocument);
                }

                // TheFile will contain the same value as the return value for this function.
                IFCImportFile.Create(localFileName, m_ImportOptions, ifcDocument);
            }

            if (useCachedRevitFile || IFCImportFile.TheFile != null)
            {
                IFCImportFile theFile = IFCImportFile.TheFile;
                if (theFile != null)
                {
                    if (theFile.IFCProject != null)
                    {
                        IFCObjectDefinition.CreateElement(ifcDocument, theFile.IFCProject);
                    }

                    // Also process any other entities to create.
                    foreach (IFCObjectDefinition objDef in IFCImportFile.TheFile.OtherEntitiesToCreate)
                    {
                        IFCObjectDefinition.CreateElement(ifcDocument, objDef);
                    }

                    theFile.EndImport(ifcDocument, localFileName);
                }

                if (TheOptions.Action == IFCImportAction.Link)
                {
                    // If we have an original Revit link file name, don't create a new RevitLinkType -
                    // we will use the existing one.
                    bool      useExistingType = (TheOptions.RevitLinkFileName != null);
                    ElementId revitLinkTypeId = IFCImportFile.LinkInFile(origFullFileName, localFileName, ifcDocument, originalDocument, useExistingType, !useCachedRevitFile);
                }
            }

            if (m_ImportCache != null)
            {
                m_ImportCache.Reset(ifcDocument);
            }
        }
Example #3
0
        /// <summary>
        /// Import an IFC file into a given document for Reference only.
        /// </summary>
        /// <param name="document">The host document for the import.</param>
        /// <param name="fullFileName">The full file name of the document.</param>
        /// <param name="options">The list of configurable options for this import.</param>
        public void ReferenceIFC(Document document, string fullFileName, IDictionary <String, String> options)
        {
            // An early check, based on the options set - if we are allowed to use an up-to-date existing file on disk, use it.
            m_ImportLog = IFCImportLog.CreateLog(fullFileName, "log.html");

            Document originalDocument = document;
            Document ifcDocument      = null;

            if (TheOptions.Action == IFCImportAction.Link)
            {
                string linkedFileName = IFCImportFile.GetRevitFileName(fullFileName);

                ifcDocument = LoadOrCreateLinkDocument(originalDocument, linkedFileName);
                if (ifcDocument == null)
                {
                    return;
                }
            }
            else
            {
                ifcDocument = originalDocument;
            }

            bool useCachedRevitFile = DocumentUpToDate(ifcDocument, fullFileName);

            // In the case where the document is already opened as a link, but it has been updated on disk,
            // give the user a warning and use the cached value.
            if (!useCachedRevitFile && ifcDocument.IsLinked)
            {
                useCachedRevitFile = true;
                Importer.AddDelayedLinkError(BuiltInFailures.ImportFailures.IFCCantUpdateLinkedFile);
            }

            if (!useCachedRevitFile)
            {
                m_ImportCache = IFCImportCache.Create(ifcDocument, fullFileName);

                // Limit creating the cache to Link, but may either remove limiting or make it more restrict (reload only) later.
                if (TheOptions.Action == IFCImportAction.Link)
                {
                    TheCache.CreateExistingElementMaps(ifcDocument);
                }

                // TheFile will contain the same value as the return value for this function.
                IFCImportFile.Create(fullFileName, m_ImportOptions, ifcDocument);
            }

            if (useCachedRevitFile || IFCImportFile.TheFile != null)
            {
                IFCImportFile theFile = IFCImportFile.TheFile;
                if (theFile != null)
                {
                    if (theFile.IFCProject != null)
                    {
                        IFCObjectDefinition.CreateElement(ifcDocument, theFile.IFCProject);
                    }

                    // Also process any other entities to create.
                    foreach (IFCObjectDefinition objDef in IFCImportFile.TheFile.OtherEntitiesToCreate)
                    {
                        IFCObjectDefinition.CreateElement(ifcDocument, objDef);
                    }

                    theFile.EndImport(ifcDocument, fullFileName);
                }

                if (TheOptions.Action == IFCImportAction.Link)
                {
                    // If we have an original Revit link file name, don't create a new RevitLinkType -
                    // we will use the existing one.
                    bool      useExistingType = (TheOptions.RevitLinkFileName != null);
                    ElementId revitLinkTypeId = IFCImportFile.LinkInFile(fullFileName, ifcDocument, originalDocument, useExistingType, !useCachedRevitFile);
                }
            }

            if (m_ImportCache != null)
            {
                m_ImportCache.Reset(ifcDocument);
            }
        }
Example #4
0
        public void ImportIFC(ImporterIFC importer)
        {
            TheImporter = this;

            IDictionary <String, String> options = importer.GetOptions();

            TheOptions = m_ImportOptions = IFCImportOptions.Create(options);

            // An early check, based on the options set - if we are allowed to use an up-to-date existing file on disk, use it.
            try
            {
                string revitFileName = IFCImportFile.GetRevitFileName(importer.FullFileName);
                if (!TheOptions.ForceImport && !NeedsReload(importer.FullFileName, revitFileName))
                {
                    return;
                }

                // Clear the category mapping table, to force reload of options.
                IFCCategoryUtil.Clear();

                if (TheOptions.Intent != IFCImportIntent.Reference)
                {
                    IFCImportFile.Import(importer);
                }
                else
                {
                    Document originalDocument = importer.Document;
                    Document ifcDocument      = null;

                    if (TheOptions.Action == IFCImportAction.Link)
                    {
                        string linkedFileName = IFCImportFile.GetRevitFileName(importer.FullFileName);

                        ifcDocument = LoadOrCreateLinkDocument(originalDocument, linkedFileName);
                        if (ifcDocument == null)
                        {
                            return;
                        }
                    }
                    else
                    {
                        ifcDocument = originalDocument;
                    }

                    bool useCachedRevitFile = DocumentUpToDate(ifcDocument, importer.FullFileName);

                    // In the case where the document is already opened as a link, but it has been updated on disk,
                    // give the user a warning and use the cached value.
                    if (!useCachedRevitFile && ifcDocument.IsLinked)
                    {
                        useCachedRevitFile = true;
                        Importer.AddDelayedLinkError(BuiltInFailures.ImportFailures.IFCCantUpdateLinkedFile);
                    }

                    if (!useCachedRevitFile)
                    {
                        m_ImportCache = IFCImportCache.Create(ifcDocument, importer.FullFileName);

                        // Limit creating the cache to Link, but may either remove limiting or make it more restrict (reload only) later.
                        if (TheOptions.Action == IFCImportAction.Link)
                        {
                            TheCache.CreateExistingElementMaps(ifcDocument);
                        }

                        // TheFile will contain the same value as the return value for this function.
                        IFCImportFile.Create(importer.FullFileName, m_ImportOptions, ifcDocument);
                    }

                    if (useCachedRevitFile || IFCImportFile.TheFile != null)
                    {
                        if (IFCImportFile.TheFile != null)
                        {
                            if (IFCImportFile.TheFile.IFCProject != null)
                            {
                                IFCObjectDefinition.CreateElement(ifcDocument, IFCImportFile.TheFile.IFCProject);
                            }
                            IFCImportFile.TheFile.EndImport(ifcDocument, importer.FullFileName);
                        }

                        if (TheOptions.Action == IFCImportAction.Link)
                        {
                            // If we have an original Revit link file name, don't create a new RvtLinkSymbol -
                            // we will use the existing one.
                            bool useExistingType = (TheOptions.RevitLinkFileName != null);
                            IFCImportFile.LinkInFile(importer.FullFileName, ifcDocument, originalDocument, useExistingType, !useCachedRevitFile);
                        }
                    }

                    m_ImportCache.Reset(ifcDocument);
                }
            }
            catch (Exception ex)
            {
                if (IFCImportFile.TheFile != null)
                {
                    IFCImportFile.TheFile.Log.LogError(-1, ex.Message, false);
                }
            }
            finally
            {
                if (IFCImportFile.TheFile != null)
                {
                    IFCImportFile.TheFile.Close();
                }
            }
        }