DXFWriter.h

Go to the documentation of this file.

/**--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: CAD
File: DXFWriter
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include "EntityCodes.h"
#include "CADEntityStreamer.h"
#include "Base/Headers/GenericOptions.h"
#include "Base/Headers/String.h"
#include "Base/Headers/Line.hpp"
#include "Base/Headers/PolyLine.hpp"
#include <fstream>
namespace NDEVR
{
    class DXFValueManager;
    class File;
    class CADHandleManager;
    class DXFWriter;
    class XDataWriter : public HandleData
    {
    public:
        std::function<void(DXFWriter& dxf)> write_function;
    };
    class NDEVR_CAD_API DXFWriter
    {
    public:
        explicit DXFWriter();
        const DynamicPointer<CADHandleManager>& handleManager() const { return m_handle_manager; };
        void setHandleManager(const DynamicPointer<CADHandleManager>& manager);
        void setFileTarget(File& file);
        void setVersion(DXFVersion version);
        void writeAPPIDTable();
        void writeDimStyleTable();
        void writeViewTable();
        void writeStyleTable();
        void writeUCSTable();
        void writeClasses();
        void writeLTypeTable();
        void writeOptions(const Buffer<CADVariable>& data);
        void startBlocks(const Buffer<BlockData>& data);
        void startBlock(const BlockData& data);
        void endBlock(const BlockData& data);
        void addDictionary(const String& dictionary_name, const CADDictionaryObject& dictionary);
        void startEntities();
        void writeObjects();
        void writeDictionaries();
        void writeViewStyleObject();
        void writeReactors(uint04 dictionary_handle);
        void writeVariableValue(const CADVariable& variable);
        void finish();
        static bool getFileLine(String& s, std::ifstream& in, bool stripSpace = true);
        void writeAttributesFast(const EntityData& data);
        bool addColorInfo(const CADColorInfo& data, bool is_off = false);
        void writeLabel(uint02 value_index);
        void writeInteger(uint02 value_index);
        void writeIntegerL(uint04 value_index);
        void writeIntegerL(sint04 value_index);
        void writeIntegerS(uint01 value_index);
        void writeInteger(sint02 value_index);
        void writeDouble(fltp08 value_index);
        void writeValue(uint02 value_index, const String& value);
        void writeHandle(uint02 value_index, const uint04& value);
        void writeValue(uint02 value_index, const char* const value);
        void writeValue(uint02 value_index, uint04 value);
        void writeValueL(uint02 value_index, sint04 value);
        void writeValueL(uint02 value_index, uint04 value);
        void writeValueS(uint02 value_index, uint01 value);
        void writeValue(uint02 value_index, sint04 value);
        void writeValue(uint02 value_index, fltp08 value);
        void writeValue(uint02 value_index, fltp04 value);
        void writeDictionary(const CADDictionaryObject& data);
        void writeValue(uint02 value_index, const Vector<3, fltp08>& value);
        void writeViewports(Buffer<ViewportData> cameras);
        void writeVPortTableEntree(const ViewportData& data);
        void startLayers(uint04 max_layer_count);
        void addLayer(const LayerData& data);
        void addPoint(const PointData& point);
        void addAttribute(const Attrib& attrib);
        void startFastPoints();
        void addFastPoint(const PointData& face);
        void endFastPoints();
 
        void addLine(const LineData& line);
        void addXLine(const LineSegment<3, fltp08>& line);
        void addRay(const LineSegment<3, fltp08>& line);
        void addMesh(const CADMeshData& data);
        
        void addPolyline(const PolylineData& data);
        void addPolyline(const PolylineData& data, const Polyline<3, fltp08>& poly);
        void addPolyline(const Polyline<3, fltp08>& poly);
        void addVertex(const Vector<3, fltp08>& point);
 
        void addSpline();
        
        void addArc();
        void addCircle();
        void addEllipse();
        void addInsert(const BlockInsert& insert);
 
        void cleanupCADName(String& name);
 
        void addTrace(bool is_solid, const TraceData& face);
        void add3dFace(bool is_solid, const Triangle<3, fltp08>& tri);
        void add3dFace(bool is_solid, const TraceData& face);
        //Use this when writing many 3D faces
        void startFast3DFaces(bool is_solid);
        void addFast3dFace(bool is_solid, const TraceData& face);
        void endFast3DFaces();
        Buffer<BlockData> defaultBlocks();
 
        void addText(const TextData& data);
        void addMText(const TextData& data);
        uint04 generateTempHandleIndex();
        uint04 getHandleIndex(const String& handle_name);
        void addAttribute();
        
        void addDimLinear();
        void addDimAligned(const DimAlignedData& alignment);
        void addDimRadial();
        void addDimDiametric();
        void addDimAngular();
        void addDimAngular3P();
        void addDimOrdinate();
        
        /*void addLeader();
 
        void addHatch();
        void addHatchLoop();
        void addHatchEdge();
        bool handleHatchData();
 
        void addImage();*/
        void addImageDef();
        void addMaterialObject(const DXFMaterial& material);
        void setBinary(bool is_binary) { m_is_binary = is_binary; }
        bool handleMTextData();
        bool handleLWPolylineData();
        bool handleLinetypeData();
        void endEntity();
        void setDecimalPlaces(uint04 decimals) { m_decimal_places = decimals; }
        void endSequence();
        XDataWriter createVertexXData(uint04 start_offset, const Buffer<Vertex<3, fltp08>>& vertices);
        XDataWriter createVertexXData(uint04 start_offset, const Buffer<RGBColor>& vertices);
        bool writePointers() const { return m_write_pointers; }
    private:
        void writeDimensionData(const DimensionData& data);
        void writeCache();
        enum VertexMode
        {
              e_polyline
            , e_3D_mesh
        };
        DynamicPointer<CADHandleManager> m_handle_manager;
        uint04 m_current_line;
        String m_polyline_layer;
        Buffer<Vector<4, fltp08>> m_vertices;
        //bool m_x_recordValues;
        VertexMode m_vertex_mode;
        String m_group_code_tmp;
        uint04 m_group_code;
        String m_group_value;
        // Value of the current setting
        String m_setting_value;
        // Key of the current setting (e.g. "$ACADVER")
        String m_setting_key;
        // app specific dictionary handle:
        //uint08 m_dictionary_handle;
        // handle of standard text style, referenced by dimstyle:
        //uint08 m_style_handle;
        std::ofstream m_out;
        String m_fast_data;
        String m_cache;
        uint04 m_cache_size;
        
        bool m_write_pointers = true;
        bool m_write_parent_pointers = true;
        bool m_write_classes = true;
        bool m_write_general_view_style = true;
        bool m_write_viewports = true;
        bool m_write_dim_style = true;
        bool m_has_block_data = false;
        bool m_is_binary = false;
        //uint04 m_decimal_places = Constant<uint04>::NaN;
        uint04 m_decimal_places = 4;
        DXFVersion m_version = DXFVersion::e_AC1021;
        Buffer<CADDictionaryObject> m_dictionary_objects;
        Dictionary<String, CADDictionaryObject> m_named_dictionary_objects;
        Buffer<XDataWriter> m_xdata_objects;
    };
}