DXFBlockWriter.h

Go to the documentation of this file.

#pragma once
#include "CAD/Headers/DXFFactory.h"
#include "CAD/Headers/CADGeometryWriter.h"
#include "CAD/Headers/EntityConverter.h"
#include "CAD/Headers/DXFReader.h"
#include "CAD/Headers/DXFWriter.h"
#include "CAD/Headers/CADWriteModifier.h"
#include "CAD/Headers/CADHandleManager.h"
 
#include "IOFactory/Headers/FactoryFeatures.h"
 
#include "Design/Headers/Text.h"
#include "Design/Headers/Material.h"
#include "Design/Headers/Project.h"
#include "Design/Headers/Model.h"
#include "Design/Headers/Geometry.h"
#include "Design/Headers/ImageFactory.h"
#include "Design/Headers/DesignObjectLookup.h"
 
#include "Base/Headers/Exception.h"
#include "Base/Headers/Pointer.hpp"
#include "Base/Headers/JSONParser.h"
#include "Base/Headers/FileFormat.h"
#include "Base/Headers/ACIColor.h"
#include "Base/Headers/MatrixFunctions.h"
namespace NDEVR
{
    void convertToPlacementData(PlacementData& data, Matrix<fltp08> transform)
    {
        
        Ray<3, fltp08> up(0.0, 0.0, 1.0);
        data.extrusion = (transform * up).normalized<fltp08>();
        transform = EntityConverter::GetOrientation(data.extrusion) * transform;
        data.offset = transform.decomposeOffset();
        auto rotation = transform.decomposeRotation<fltp08>();
        data.scale = transform.decomposeScale();
        data.azimuth = rotation[YAW];
 
    }
    bool DXFShouldExport(FactoryOptions options, const Model& model)
    {
        BitFlag flag = model.parentMatrixFlags();
        if (flag[Model::ParentMatrixFlags::e_follow_camera]
            || flag[Model::ParentMatrixFlags::e_scale_to_camera]
            || flag[Model::ParentMatrixFlags::e_orient_to_camera])
            return false;
        if (options.exclusion_model_types.contains(model.getModelProperty<String>(Model::e_type)))
            return false;
        if (model.getModelProperty<bool>(Model::e_export_ignored))
            return false;
        if (options.ignore_invisible && !model.isVisible())
            return false;
        return true;
    }
    class DXFTableWriteIterator : public ModelIterator
    {
    public:
        Buffer<CADWriteModifier*> write_modifiers;
        DynamicPointer<CADHandleManager> handle_manager;
        const FactoryParameters& params;
        DXFWriter& writer;
 
        Dictionary<String, LayerData> layers;
        Dictionary<UUID, BlockData> block_data;
        Dictionary<UUID, DXFMaterial> material_data;
        Dictionary<String, uint04> block_names;
 
 
        uint04 num_of_shapes = 0;
        const bool write_materials;
        const bool flatten_model;
        DXFTableWriteIterator(const FactoryParameters& params, DXFWriter& writer, bool write_materials)
            : handle_manager(writer.handleManager())
            , params(params)
            , writer(writer)
            , write_materials(write_materials)
            , flatten_model(params.options.flatten_model)
        {
            LayerData default_0;
            default_0.name = "0";
            default_0.color_info.color = RGBColor(255, 255, 255);
            default_0.color_info.mode = ColorMode::e_background_contrast;
            layers["0"] = default_0;
            writer.addLayer(default_0);
            model_filter = [&params](const Model& model) -> bool
            {
                return DXFShouldExport(params.options, model);
            };
 
        }
        void processTablesSection(Model& model, Geometry& geo)
        {
            uint04 primitive_count = geo.primitiveCount(PrimitiveProperty::Solid);
            if (primitive_count == 0)
                num_of_shapes += geo.vertexCount();
            else
                num_of_shapes += primitive_count;
            if (flatten_model)
            {
                BlockData data = convertToBlock(model);
                UUID id = geo.uuid().appendUUID(model.uuid());
                data.handle = handle_manager->getHandleIndex(id);
                block_data.insert({ id, data });
            }
        }
        ParseResult process(Model& model, Geometry& geo) final override
        {
            if (!params.options.useValue(geo.getGeometryType()))
                return ModelIterator::ParseResult::e_continue_parsing;
            processTablesSection(model, geo);
            return ModelIterator::ParseResult::e_continue_parsing;
        }
        ParseResult process(Model& model) final override
        {
            if (!flatten_model)
            {
                if (model.isScene() && model.hasMetaData("is_cad_core") && model.metaData("is_cad_core").getAs<bool>())
                {
                    //we don't add an actual block here, as the binding is "temporary"
                    convertToBlock(model);
                }
                else
                {
                    
                    for (CADWriteModifier* write_modifier : write_modifiers)
                    {
                        if (write_modifier->canHandleBlock(model))
                            return write_modifier->handleBlock(model, *this);
                    }
                    if (model.childCount() > 0 && !model.getGeometry().isValid())
                    {
                        BlockData data = convertToBlock(model);
                        data.handle = handle_manager->getHandleIndex(data.name);
                        handle_manager->setHandleToUUID(model.uuid(), data.handle);
                        handle_manager->setHandleIndex(data.name, data.handle);
                        writer.handleManager()->setTransfromCoords(data.handle
                            , params.options.units.coordinate_space_unit.get()->matrix() * model.getCompleteTransform());
                        block_data.insert({ model.uuid(), data });
                    }
                    else
                    {
                        if(model.getGeometry().isValid())
                            getMaterialHandle(model);
                        processLayerName(model, processName(model));
                    }
                }
            }
            return ModelIterator::ParseResult::e_continue_parsing;
        }
        uint04 getMaterialHandle(const Model& model)
        {
            Material material = model.getRootMaterial(PrimitiveProperty::Solid);
            if (material.isValid())
            {
                if (!material_data.hasKey(material.uuid()))
                {
                    switch (material.getUVMode(UVType::e_KD))
                    {
                    case Material::UVMode::e_color_by_layer:
                    case Material::UVMode::e_color_by_model:
                        break;
                    default:
                    {
                        uint04 handle = handle_manager->getHandleIndex(material.uuid());
                        DXFMaterial dxf_mat = convertToMaterial(material);
                        dxf_mat.handle = handle;
                        writer.cleanupCADName(dxf_mat.name);
                        material_data.insert({ material.uuid(), dxf_mat });
                        return handle;
                    } break;
                    }
                }
                else
                {
                    return handle_manager->getHandleIndex(material.uuid());
                }
            }
            return Constant<uint04>::NaN;
        }
        String processName(const Model& model) const
        {
            String name;
            if (flatten_model)
                name = model.displayNamePath("_").translation();
            else
                name = model.displayName().translation();
            name.removeAllOrdered('\r');
            name.removeAllOrdered('\n');
 
            //data.name.replace("_Deployment_1", "", true);
            name.replace("_Deployment_Linework", "", true);
            name.replace("_Deployment", "_DEPL", true);
            name.replace("Boretrak", "TRAK", true);
            name.replace("Station", "STN", true);
            name.replace("Linework_", "", true);
            name.replace("_Linework", "", true);
            name.replace("Points", "PTS", true);
            name.replace("Mesh", "MESH", true);
            name.replace("CircleScan", "CIR", true);
            name.replace("Scan", "SCAN", true);
            name.replace("Circle", "CIR", true);
            return name;
        }
        String processLayerName(const Model& model, const String& model_name)
        {
            String layer_name;
            if (!flatten_model && model.hasLayer())
            {
                LayerData layer_data;
                Model layer = model.getLayer();
                layer_name = layer.getProperty<TranslatedString>(DesignObject::e_name).translation();
                writer.cleanupCADName(layer_name);
                if (!layers.hasKey(layer_name))
                {
                    FillOutLayerData(layer, layer_data);
                    layer_data.handle = handle_manager->getHandleIndex(layer.uuid());
                    //layer_data.material_handle = getMaterialHandle(layer);
                    writer.cleanupCADName(layer_data.name);
                    writer.addLayer(layer_data);
                    layers[layer_name] = layer_data;
                }
            }
            else if (flatten_model)
            {
                layer_name = model_name;
                if (!layers.hasKey(layer_name))
                {
                    LayerData layer_data;
                    layer_data.name = layer_name;
                    layer_data.color_info = GenerateDXFColorInfo(model, flatten_model, false);
                    layers[layer_name] = layer_data;
                    writer.addLayer(layer_data);
                }
            }
            else
            {
                //layer_name = layerName(model);
                layer_name = "0";
            }
            return layer_name;
        }
        BlockData convertToBlock(const Model& model)
        {
            BlockData data;
            data.name = processName(model);
            data.description = model.getProperty<TranslatedString>(DesignObject::e_description).translation();
            data.description.replaceAll('\n', ' ');
 
            data.offset = Vertex<3, fltp08>(0.0);
 
            writer.cleanupCADName(data.name);
            if (block_names.hasKey(data.name))
            {
                block_names.get(data.name)++;
                data.name += "_" + String(block_names.get(data.name));
                writer.cleanupCADName(data.name);
            }
            else
            {
                block_names.insert({ data.name , 1 });
            }
 
            String layer_name = processLayerName(model, data.name);
            data.layer = layer_name.size() > 0 ? layer_name : String("0");
 
            data.color_info = GenerateDXFColorInfo(model, flatten_model, false);
            data.material_handle = getMaterialHandle(model);
 
 
            return data;
        }
        String getImageFile(const String& image)
        {
            if (image.size() == 0 || !ImageFactory::DefaultFactory().hasImage(image))
                return File();
            File file = ImageFactory::DefaultFactory().getFile(image);
            if (file.exists())
                return String(file);
            file = params.file().getParentDirectory();
 
            String file_name = ImageFactory::DefaultFactory().optimizedWriteFileName(image);
            
            String local_path = File::PathSepS + "Images" + File::PathSepS + file_name;
 
            file.appendPath(local_path);
            ImageFactory::DefaultFactory().writeToFile(image, file);
            return "."+local_path;
 
        }
        DXFMaterial convertToMaterial(const Material& material)
        {
            DXFMaterial dxf_mat;
            String material_name = material.getProperty<TranslatedString>(DesignObject::e_name).translation();
            dxf_mat.name = material_name;
            dxf_mat.description = material.getProperty<TranslatedString>(DesignObject::e_description).translation();
            dxf_mat.handle = handle_manager->getHandleIndex(material.uuid());
            switch (material.getUVMode(UVType::e_KD))
            {
            case Material::UVMode::e_solid_color:
                dxf_mat.diffuse.use_value = true;
                break;
            case Material::UVMode::e_image:
                dxf_mat.diffuse.map_file = getImageFile(material.getUVImage(UVType::e_KD));
                dxf_mat.diffuse.use_value = true;
                break;
            default:
                dxf_mat.diffuse.use_value = false;
                break;
            }
            
            dxf_mat.mat_matrix = material.getTransform();
            
            if (material.getShadingModel() == Material::e_gouraud)
            {
                dxf_mat.diffuse.color = (material.getUVMode(UVType::e_KD) == Material::UVMode::e_solid_color 
                    ? material.getUVColor(UVType::e_KD) : RGBColor(0, 0, 0));
                dxf_mat.ambient.color = dxf_mat.diffuse.color;
                dxf_mat.specular.color = dxf_mat.diffuse.color;
                dxf_mat.ambient.use_value = dxf_mat.diffuse.use_value;
                dxf_mat.specular.use_value = dxf_mat.diffuse.use_value;
                dxf_mat.specular.map_file = dxf_mat.diffuse.map_file;
            }
            else
            {
                switch (material.getUVMode(UVType::e_KA))
                {
                case Material::UVMode::e_solid_color:
                case Material::UVMode::e_image:
                    dxf_mat.ambient.use_value = true;
                    break;
                default:
                    dxf_mat.ambient.use_value = false;
                    break;
                }
                switch (material.getUVMode(UVType::e_KS))
                {
                case Material::UVMode::e_solid_color:
                    dxf_mat.specular.use_value = true;
                    break;
                case Material::UVMode::e_image:
                    dxf_mat.specular.map_file = getImageFile(material.getUVImage(UVType::e_KS));
                    dxf_mat.specular.use_value = true;
                    break;
                default:
                    dxf_mat.specular.use_value = false;
                    break;
                }
                dxf_mat.diffuse.color = (material.getUVMode(UVType::e_KD) == Material::UVMode::e_solid_color ? material.getUVColor(UVType::e_KD) : RGBColor(0, 0, 0));
                dxf_mat.ambient.color = (material.getUVMode(UVType::e_KA) == Material::UVMode::e_solid_color ? material.getUVColor(UVType::e_KA) : RGBColor(0, 0, 0));
                dxf_mat.specular.color = (material.getUVMode(UVType::e_KS) == Material::UVMode::e_solid_color ? material.getUVColor(UVType::e_KS) : RGBColor(0, 0, 0));
                
            }
            
            dxf_mat.diffuse.color_intensity = (material.hasUVIntensity(UVType::e_KD) ? material.getUVIntensity(UVType::e_KD) : 1.0f);
            dxf_mat.ambient.color_intensity = (material.hasUVIntensity(UVType::e_KA) ? material.getUVIntensity(UVType::e_KA) : 0.3f);
            dxf_mat.specular.color_intensity = (material.hasUVIntensity(UVType::e_KS) ? material.getUVIntensity(UVType::e_KS) : 0.3f);
            dxf_mat.specular_gloss_factor = material.getMaterialProperty<fltp04>(Material::e_shininess);
            if (isNaN(dxf_mat.specular_gloss_factor))
                dxf_mat.specular_gloss_factor = 0.5;
            
            dxf_mat.opacity_percent = (material.getMaterialProperty<fltp04>(Material::e_opacity));
            return dxf_mat;
        }
 
    };
    
    class DXFBlockWriter : public ModelIterator
    {
    public:
        const Dictionary<UUID, BlockData>& block_data;
        const FactoryParameters& params;
        DXFWriter& writer;
        CADGeometryWriter& geo_options;
        Buffer<CADWriteModifier*> write_modifiers;
        DXFBlockWriter(Dictionary<UUID, BlockData>& block_data, CADGeometryWriter& geo_options)
            : block_data(block_data)
            , params(geo_options.params)
            , writer(geo_options.writer)
            , geo_options(geo_options)
        {
 
            model_filter = [this](const Model& model) -> bool
            {
                return DXFShouldExport(params.options, model);
            };
            post_process_model = true;
        }
        void insertObject(const Model& model, uint04 parent_handle = Constant<uint04>::NaN)
        {
            
            UUID id = model.uuid();
            if (!DXFShouldExport(params.options, model))
                return;
 
            for (CADWriteModifier* write_modifier : write_modifiers)
            {
                if (write_modifier->canHandleInsert(model))
                {
                    Matrix<fltp08> transform = writer.handleManager()->transfromCoords(parent_handle).invert()
                        * params.options.units.coordinate_space_unit.get()->matrix() * model.getCompleteTransform();
                    write_modifier->handleInsert(transform, model, parent_handle, *this);
                    return;
                }
            }
            if (!block_data.hasKey(id))
            {
                
                Matrix<fltp08> transform = writer.handleManager()->transfromCoords(parent_handle).invert() 
                    * params.options.units.coordinate_space_unit.get()->matrix() * model.getCompleteTransform();
                
                geo_options.layer_name.clear();
                geo_options.parent_handle = parent_handle;
                if (Geometry geo = model.getGeometry())
                {
                    geo_options.setup(model, geo);
                    geo_options.transform = transform * geo.getTransform();
                    geo_options.writeGeometry();
                }
            }
            else
            {
                const BlockData& block_info = block_data.get(id);
                BlockInsert block_insert;
                block_insert.block_name = block_info.name;
                block_insert.parent_handle = parent_handle;
                block_insert.material_handle = block_info.material_handle;
                block_insert.handle = writer.handleManager()->getHandleIndex(model.uuid());
                Matrix<fltp08> complete_transform = params.options.units.coordinate_space_unit.get()->matrix() * model.getCompleteTransform();
                Matrix<fltp08> transform = writer.handleManager()->transfromCoords(parent_handle).invert() * complete_transform;
                convertToPlacementData(block_insert, transform);
                writer.handleManager()->setTransfromCoords(block_insert.handle, complete_transform);
                FillOutData(model, block_insert);
                writer.cleanupCADName(block_insert.layer);
                block_insert.color_info = GenerateDXFColorInfo(model, params.options.flatten_model, false);
                writer.addInsert(block_insert);
            }
        }
        ParseResult process(Model& model) final override
        {
            for (CADWriteModifier* write_modifier : write_modifiers)
            {
                if (write_modifier->canHandleBlock(model))
                    return ModelIterator::ParseResult::e_do_not_parse_children;
            }
            return ModelIterator::ParseResult::e_continue_parsing;
        }
        ParseResult postProcess(Model& model) final override
        {
            if (!DXFShouldExport(params.options, model))
                return ParseResult::e_do_not_parse_children;
            for (CADWriteModifier* write_modifier : write_modifiers)
            {
                if (write_modifier->canHandleBlock(model))
                    return write_modifier->handleBlock(model, *this);
            }
            if (block_data.hasKey(model.uuid()))
            {
                const BlockData& block = block_data.get(model.uuid());
                writer.startBlock(block);
                Buffer<Model> children = model.getChildren();
                for (const Model& model : children)
                    insertObject(model, block.handle);
                if (Geometry geo = model.getGeometry())
                {
                    Matrix<fltp08> transform = writer.handleManager()->transfromCoords(block.handle).invert()
                        * params.options.units.coordinate_space_unit.get()->matrix() * model.getCompleteTransform();
                    geo_options.parent_handle = block.handle;
                    geo_options.setup(model, geo);
                    geo_options.transform = transform * geo.getTransform();
                    geo_options.writeGeometry();
 
                }
                writer.endBlock(block);
                return ModelIterator::ParseResult::e_continue_parsing;
            }
            else
            {
                if (model.isScene() && model.hasMetaData("is_cad_core") && model.metaData("is_cad_core").getAs<bool>())
                    return ModelIterator::ParseResult::e_continue_parsing;
                return ModelIterator::ParseResult::e_do_not_parse_children;
            }
 
        }
    };
 
    
}