CADGeometryWriter.h

Go to the documentation of this file.

#pragma once
#include "CAD/Headers/DXFWriter.h"
#include "IOFactory/Headers/IOFactory.h"
#include "IOFactory/Headers/FactoryFeatures.h"
#include "Design/Headers/DesignObject.h"
#include "Design/Headers/Material.h"
#include "Design/Headers/Project.h"
#include "Design/Headers/VertexColorIterator.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
{
    CADColorInfo GenerateDXFColorInfo(const Model& model, bool is_flat, bool is_vertex)
    {
        CADColorInfo data;
 
        Material mat = model.getRootMaterial(PrimitiveProperty::Solid);
        if (!mat.isValid())
        {
            data.mode = ColorMode::e_background_contrast;
            return data;
        }
        auto mode = mat.getUVMode(UVType::e_KD);
        if (model.isLayer())
            mode = Material::UVMode::e_color_by_model;
        switch (mode)
        {
        case Material::UVMode::e_background:
        case Material::UVMode::e_background_contrast_plus_solid:
        case Material::UVMode::e_background_contrast:
            data.mode = ColorMode::e_background_contrast;
            break;
        case Material::UVMode::e_color_by_model:
            if (is_flat || model.hasMaterial(PrimitiveProperty::Solid) || model.isLayer())
            {
                data.color = model.customModelColor(Model::ModelColorMode::e_by_material_root);
                if (isNaN(data.color))
                    data.mode = e_background_contrast;
                else
                    data.mode = e_use;
            }
            else
            {
                data.mode = e_by_block;
            }
            break;
        case Material::e_color_by_layer:
            if (is_flat)
            {
                data.color = model.customModelColor(Model::ModelColorMode::e_by_layer);
                if (isNaN(data.color))
                    data.mode = e_background_contrast;
                else
                    data.mode = e_use;
            }
            else
            {
                data.mode = ColorMode::e_by_layer;
            } break;
        case Material::UVMode::e_solid_color:
            data.color = mat.getUVColor(UVType::e_KD);
            if(!isNaN(data.color))
                data.mode = e_use;
            else
                data.mode = e_background_contrast;
            break;
        case Material::UVMode::e_image:
        case Material::UVMode::e_color_channel:
        case Material::UVMode::e_scaled_channel:
            if (is_vertex)
                data.mode = e_use;
            else
                data.mode = e_background_contrast;
            break;
        default:
            lib_assert(false, "Unknown property");
        }
        return data;
 
    }
    String layerName(const Model& model)
    {
        String layer_name;
        if (model.hasLayer())
        {
            Model layer = model.getLayer();
            layer_name = layer.getProperty<TranslatedString>(Model::e_name).translation();
        }
        if (layer_name.size() == 0)
        {
            layer_name = "0";
            /*Material mat = model.getRootMaterial(PrimitiveProperty::Solid);
            layer_name = mat.getProperty<TranslatedString>(DesignObject::e_name).translation();
            if (layer_name.size() == 0)
                layer_name = String(ACIColor(mat.getUVColor(UVType::e_KD)).getIndex());*/
        }
        return layer_name;
    }
    void FillOutLayerData(const Model& layer, LayerData& data)
    {
        //data.handle = String(model.uuid());
        //data.is_off = !layer.isVisible();
        data.visible = layer.isVisible();
        String layer_name = layer.getProperty<TranslatedString>(DesignObject::e_name).translation();
        data.name = layer_name.size() > 0 ? layer_name : String("0");
        data.color_info = GenerateDXFColorInfo(layer, true, false);
    }
    void FillOutData(const Model& model, EntityData& data)
    {
        //data.handle = String(geo.uuid());
        //data.is_off = !model.isVisible();
        data.visible = model.isVisible();
        data.layer = layerName(model);
    }
    
    struct CADGeometryWriter
    {
        FactoryParameters& params;
        DXFWriter& writer;
        CADColorInfo model_color_info;
        DXFEntityCodes default_mesh_output = DXFEntityCodes::e_dxf_ENTITY_3DFACE;
        Matrix<fltp08> transform;
        Model model;
        Geometry geometry;
        Material material;
        String layer_name;
        uint04 num_of_shapes;
        uint04 shapes_written;
        uint04 parent_handle;
 
        Matrix<fltp08> model_transform;
        bool has_solid_color = true;
 
        CADGeometryWriter(DXFWriter& writer, FactoryParameters& params)
            : params(params)
            , writer(writer)
            , num_of_shapes(0)
            , shapes_written(0)
            , parent_handle(Constant<uint04>::NaN)
        {}
        void onShapeWritten()
        {
            shapes_written++;
            if (params.log && shapes_written % 1000 == 0)
            {
                if (!params.log->setProgress(cast<fltp04>(shapes_written) / cast<fltp04>(num_of_shapes)))
                    throw CancelException(_t("Writing DXF Canceled"));
            }
        }
        void setup(const Model& m, const Geometry& geo)
        {
            model = m;
            geometry = geo;
            model_color_info = GenerateDXFColorInfo(model, params.options.flatten_model, true);
            material = model.getRootMaterial(PrimitiveProperty::Solid);
            model_transform = m.getCompleteTransform() * geo.getTransform();
            switch (material.getUVMode(UVType::e_KD))
            {
            case Material::UVMode::e_background:
            case Material::UVMode::e_color_by_model:
            case Material::UVMode::e_color_by_layer:
            case Material::UVMode::e_solid_color:
            case Material::UVMode::e_background_contrast_plus_solid:
            case Material::UVMode::e_background_contrast:
                has_solid_color = true;
                break;
            case Material::UVMode::e_image:
            case Material::UVMode::e_color_channel:
            case Material::UVMode::e_scaled_channel:
                has_solid_color = false;
                break;
            default:
                has_solid_color = true;
                lib_assert(false, "Unknown property");
            }
        }
        void fillOutData(EntityData& data)
        {
            FillOutData(model, data);
            data.color_info = model_color_info;
            if(writer.handleManager()->hasHandleIndex(material.uuid()))
                data.material_handle = writer.handleManager()->getHandleIndex(material.uuid());
            if (!params.options.flatten_model)
                data.parent_handle = parent_handle;
            else
                data.layer = layer_name;
            writer.cleanupCADName(data.layer);
        }
        void writeAsPointData()
        {
            PointData data;
 
            fillOutData(data);
            //data.thickness = geo.getGeometryProperty<fltp08>(Geometry::e_thickness);
            writer.startFastPoints();
            data.handle = writer.handleManager()->getHandleIndex(model.uuid());
            VertexIterator<Vertex<3, fltp08>> position_iterator(VertexProperty::Position, geometry);
            VertexColorIterator color_iterator(model, geometry, material, UVType::e_KD);
            for (uint04 i = 0; i < position_iterator.size(); i++)
            {
                Vertex<3, fltp08> point = position_iterator[i];
                bool filtered = (position_iterator.flag(i)[cast<uint01>(VertexFlags::e_is_filtered)]);
                if (!isNaN(point) && !filtered)
                {
                    data.location = transform * point;
                    if (!has_solid_color)
                        data.color_info.color = color_iterator[i];
                    //else stays same as geo color
                    writer.addFastPoint(data);
                    data.handle = Constant<uint04>::NaN;
                }
                onShapeWritten();
            }
            writer.endFastPoints();
        }
        void writeAsLines()
        {
            LineData data;
            fillOutData(data);
            FillOutData(model, data);
            data.thickness = geometry.getGeometryProperty<fltp08>(Geometry::e_thickness);
            data.handle = writer.handleManager()->getHandleIndex(model.uuid());
            uint04 size = geometry.primitiveCount(PrimitiveProperty::Solid);
            if (geometry.mode(PrimitiveProperty::Outline) == PrimitiveMode::e_polyline)
                size--;
 
            VertexIterator<Vertex<3, fltp08>> position_iterator(VertexProperty::Position, geometry);
            VertexColorIterator color_iterator(model, geometry, material, UVType::e_KD);
 
            for (uint04 i = 0; i < size; i++)
            {
                Vector<2, uint04> verts = geometry.primitive<Vector<2, uint04>>(PrimitiveProperty::Outline, i);
                if (isNaN(verts))
                    continue;
                LineSegment<3, fltp08> seg(position_iterator[verts[A]], position_iterator[verts[B]]);
                if (!isNaN(seg))
                {
                    data.line = transform * seg;
                    if (!has_solid_color)
                    {
                        
                        data.color_info.color = RGBColor::Average(color_iterator[verts[0]], color_iterator[verts[B]]);
                    }
                    writer.addLine(data);
                    data.handle = Constant<uint04>::NaN;
                }
                onShapeWritten();
            }
        }
        void writeAsPolyline()
        {
            PolylineData data;
            data.flags[PolylineData::e_is_3D_polyline] = true;
            data.thickness = geometry.getGeometryProperty<fltp08>(Geometry::e_thickness);
            fillOutData(data);
            data.handle = writer.generateTempHandleIndex();
            data.handle = writer.handleManager()->getHandleIndex(model.uuid());
            Buffer<Polyline<3, fltp08>> polylines = geometry.polylines<3, fltp08>(PrimitiveProperty::Outline, VertexProperty::Position);
            for (uint04 i = 0; i < polylines.size(); i++)
            {
                writer.addPolyline(data, transform * polylines[i]);
                data.handle = writer.generateTempHandleIndex();
                onShapeWritten();
            }
        }
        void writeAsTriangleLines()
        {
            LineData data;
            fillOutData(data);
            data.thickness = geometry.getGeometryProperty<fltp08>(Geometry::e_thickness);
            data.handle = writer.handleManager()->getHandleIndex(model.uuid());
            TriangleIterator<3, fltp08> tris(PrimitiveProperty::Solid, VertexProperty::Position, geometry);
            VertexColorIterator color_iterator(model, geometry, material, UVType::e_KD);
            for (uint04 i = 0; i < tris.size(); i++)
            {
                Triangle<3, fltp08> tri = tris[i];
                if (!isNaN(tri) && abs(tri.area<fltp08>()) > 0.0)
                {
                    Vector<3, RGBColor> color;
                    if (!has_solid_color)
                    {
                        Vector<3, uint04> index = tris.vertexIndex(i);
                        color[A] = color_iterator[index[A]];
                        color[B] = color_iterator[index[B]];
                        color[C] = color_iterator[index[C]];
                    }
                    data.line = transform * tri.edge(A, B);
                    if (!has_solid_color)
                        data.color_info.color = RGBColor::Average(color[A], color[B]);
                    writer.addLine(data);
                    data.handle = Constant<uint04>::NaN;
 
                    data.line = transform * tri.edge(B, C);
                    if (!has_solid_color)
                        data.color_info.color = RGBColor::Average(color[B], color[C]);
                    writer.addLine(data);
 
                    data.line = transform * tri.edge(C, A);
                    if (!has_solid_color)
                        data.color_info.color = RGBColor::Average(color[C], color[A]);
                    writer.addLine(data);
                }
                onShapeWritten();
            }
        }
        void writeAs3DFace()
        {
            TraceData data;
            fillOutData(data);
            writer.startFast3DFaces(false);
            data.handle = writer.handleManager()->getHandleIndex(model.uuid());
            TriangleIterator<3, fltp08> tris(PrimitiveProperty::Solid, VertexProperty::Position, geometry);
            VertexColorIterator color_iterator(model, geometry, material, UVType::e_KD);
            for (uint04 i = 0; i < tris.size(); i++)
            {
                Triangle<3, fltp08> tri = tris[i];
                if (!isNaN(tri) && abs(tri.area<fltp08>()) > 0.0)
                {
                    if (!has_solid_color)
                    {
                        Vector<3, uint04> index = tris.vertexIndex(i);
                        data.color_info.color = RGBColor::Average(
                              color_iterator[index[A]]
                            , color_iterator[index[B]]
                            , color_iterator[index[C]]);
                    }
                    data.points[A] = transform * tri[A];
                    data.points[B] = transform * tri[B];
                    data.points[C] = transform * tri[C];
                    writer.addFast3dFace(false, data);
                    data.handle = Constant<uint04>::NaN;
                }
                onShapeWritten();
            }
            writer.endFast3DFaces();
        }
        Vertex<3, fltp08>& CleanupDXFVertex(Vertex<3, fltp08>& vert)
        {
            for (uint04 i = 0; i < 3; i++)
            {
                if (isNaN(vert[i]))
                    vert[i] = 0.0;
            }
            return vert;
        }
        void writeAsMesh()
        {
            CADMeshData data;
            fillOutData(data);
            data.handle = writer.handleManager()->getHandleIndex(model.uuid());
            data.vertices = geometry.vertices<Vertex<3, fltp08>>(VertexProperty::Position);
            switch (geometry.mode(VertexProperty::Normal))
            {
            case Geometry::VertexMode::e_cartesian_3F:
            case Geometry::VertexMode::e_cartesian_3D:
                data.normals = geometry.vertices<Vertex<3, fltp08>>(VertexProperty::Normal);
                for (uint04 i = 0; i < data.normals.size(); i++)
                    data.normals[i] = transform * Ray<3, fltp08>(CleanupDXFVertex(data.normals[i]));
                break;
            default:
                break;
            }
            switch (geometry.mode(VertexProperty::Texture))
            {
            case Geometry::VertexMode::e_cartesian_3F:
            case Geometry::VertexMode::e_cartesian_3D:
            case Geometry::VertexMode::e_cartesian_2F:
            case Geometry::VertexMode::e_cartesian_2D:
                data.textures = geometry.vertices<Vertex<3, fltp08>>(VertexProperty::Texture);
                for (uint04 i = 0; i < data.textures.size(); i++)
                    CleanupDXFVertex(data.textures[i]);
                break;
            default:
                break;
            }
            if (!has_solid_color)
            {
                VertexColorIterator color_iterator(model, geometry, material, UVType::e_KD);
                data.colors.setSize(data.vertices.size());
                for (uint04 i = 0; i < data.vertices.size(); i++)
                    data.colors[i] = color_iterator[i];
            }
            Material material = model.getMaterial(PrimitiveProperty::Solid);
            data.material_handle = writer.handleManager()->getHandleIndex(material.uuid());
            Buffer<Buffer<uint04>> polylines = geometry.polyIndices(PrimitiveProperty::Outline);
            for (uint04 i = 0; i < polylines.size(); i++)
            {
                bool invalid = false;
                for (uint04 n = 0; n < polylines[i].size(); n++)
                {
                    if (isNaN(polylines[i][n]))
                    {
                        invalid = true;
                        break;
                    }
                    if (isNaN(data.vertices[polylines[i][n]]))
                    {
                        invalid = true;
                        break;
                    }
                }
                if (invalid)
                    continue;
                data.face_points.add(polylines[i].size());
                for (uint04 n = 0; n < polylines[i].size(); n++)
                {
                    data.face_points.add(polylines[i][n]);
                }
                onShapeWritten();
            }
            for (uint04 i = 0; i < data.vertices.size(); i++)
                data.vertices[i] = transform * CleanupDXFVertex(data.vertices[i]);
            writer.addMesh(data);
        }
        void writeGeometry()
        {
            switch (geometry.getGeometryType())
            {
            default:
                lib_assert(false, "unknown geometry type");
                break;
            case GeometryType::e_points:
                writeAsPointData();
                break;
            case GeometryType::e_linework:
            {
                if (has_solid_color)
                {
                    switch (geometry.mode(PrimitiveProperty::Outline))
                    {
                    default:
                        lib_assert(false, "unknown line type");
                        break;
                    case PrimitiveMode::e_lines:
                        writeAsLines();
                        break;
                    case PrimitiveMode::e_polyline:
                        writeAsPolyline();
                        break;
                    }
                }
                else
                {
                    writeAsLines();
                }
 
            } break;
            case GeometryType::e_triangles:
            case GeometryType::e_concave_polygons:
            case GeometryType::e_convex_polygons:
            {
                switch (default_mesh_output)
                {
                case DXFEntityCodes::e_dxf_ENTITY_LINE:
                    writeAsTriangleLines();
                    break;
                case DXFEntityCodes::e_dxf_ENTITY_3DFACE:
                    writeAs3DFace();
                    break;
                default:
                case DXFEntityCodes::e_dxf_ENTITY_MESH:
                    writeAsMesh();
                    break;
                case DXFEntityCodes::e_dxf_ENTITY_POLYLINE:
                    writeAsPolyline();
                    break;
                }
            } break;
            }
        }
    };
}